package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.calc.QueryStandardDataDetailComReqDto;
import com.sg.dto.integration.calc.QueryStandardDataDetailComRespDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerListComReqDto;
import com.sg.service.base.app.*;
import com.sg.service.biz.app.*;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.dal.po.mbg.*;
import com.wicket.okrcalc.integration.StandardDataService;
import com.wicket.okrcalc.integration.FwCalcTargetCycleClient;
import com.wicket.okrcalc.integration.dto.*;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrcomponent.integration.FwCompStandardDataClient;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrfinance.integration.FinanceService;
import com.wicket.okrfinance.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class StandardDataServiceImpl
        implements com.wicket.okrapp.biz.service.StandardDataService {

    @Resource
    private RedisUtil redisUtil;
    //@Resource
    //private MCustomFields3Service mCustomFields3Service;
    @Resource
    private NbStandardData nbStandardData;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private MOmsCycleService mOmsCycleService;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private CycleTypeService cycleTypeService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private TargetCycleService targetCycleService;
    @Resource
    private StandardDataService fwCalcStandardDataClient;
    @Resource
    private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
    @Resource
    private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private FwCalcTargetCycleClient fwCalcTargetCycleClient;
    @Resource
    private TargetContentService targetContentService;
    @Resource
    private CycleStageDataService cycleStageDataService;
    @Resource
    private GridCalculateService gridCalculateService;
    @Resource
    private ExecuteCycleService executeCycleService;
    @Resource
    private VirtualOrgService virtualOrgService;
    @Resource
    private EvaThemeService evaThemeService;
    //@Resource
    //private MOmsAccountService mOmsAccountService;
    @Resource
    private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
    //@Resource
    //private MMmmShellService mMmmShellService;
    @Resource
    private FinanceService fwFinanceFinanceClient;
    @Resource
    private TaskService taskService;
    //@Resource
    //private MCustomFields4Service mCustomFields4Service;
    @Resource
    private FinanceService financeService;
    @Resource
    private MOmsTargetObjectiveService mOmsTargetObjectiveService;
    @Resource
    private FwCompStandardDataClient fwCompStandardDataClient;
    @Resource
    private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
    @Resource
    private MOmsEvaObjTargetCycleWeightSetService mOmsEvaObjTargetCycleWeightSetService;
    @Resource
    private TargetCalcService targetCalcService;
    @Resource
    private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
//@Resource
    //private MSpecMethordTableService mSpecMethordTableService;
//@Resource
    //private undefinedService undefinedService;

    /**
     * D3-查询得分权重准备详情(公共)[6010]
     * gen by moon at 3/3/2023, 11:44:28 PM
     */
    @Trace(operationName = "D3-查询得分权重准备详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPrepareForScoreWeightDetailComRespDto queryPrepareForScoreWeightDetailCom(QueryPrepareForScoreWeightDetailComReqDto reqDto) {


//      ImplementAccessParameterBizFieldRespDto receptionServiceRes_1 =null;
//if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE"))) {
//        //if(D3-查询得分权重准备详情(公共).父子中周期类型 等于 子周期)  31802
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto.setConfItemCode("SUB_PROCESS_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720224_1_31803
//queryItemMatchResultOptionToAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:720226_1_31803
//queryItemMatchResultOptionToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:720227_1_31803
//queryItemMatchResultOptionToAnswerDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720229_1_31803
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720225_1_31803
//    }
//
//    /*D2-3查子周期过程汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_2 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_1=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_1.setConfItemCode("SUB_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720290_1_31804
//queryItemMatchResultOptionToAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:720292_1_31804
//queryItemMatchResultOptionToAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:720293_1_31804
//queryItemMatchResultOptionToAnswerDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720295_1_31804
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720291_1_31804
//    }
//
//    /*D2-查子周期汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_2 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_1).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_4 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_2=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_2.setConfItemCode("SUB_ACTUAL_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720273_1_31805
//queryItemMatchResultOptionToAnswerDetailComReqDto_2.setResultAspObjType("EVA_TEMP");//sourceId:720275_1_31805
//queryItemMatchResultOptionToAnswerDetailComReqDto_2.setIsPlatData("FALSE");//sourceId:720276_1_31805
//queryItemMatchResultOptionToAnswerDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720278_1_31805
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_2.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720274_1_31805
//    }
//
//    /*D2-3查子周期实际得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_4 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_2).getData();
//
//
//
////ModelCode: receptionService
//        ImplementAccessParameterBizFieldRespDto receptionServiceRes = null;
//    if(queryItemMatchResultOptionToAnswerDetailComRespDto !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_2 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_4 !=null){
//          ImplementAccessParameterBizFieldReqDto receptionServiceReq=new ImplementAccessParameterBizFieldReqDto();
//  if(queryItemMatchResultOptionToAnswerDetailComRespDto!=null){
//      receptionServiceReq.setProcessMidWeight(queryItemMatchResultOptionToAnswerDetailComRespDto.getProcessMidWeight());//SimpleFieldAssign//sourceId:720704_1_31836
//receptionServiceReq.setReportAvgScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720705_1_31836
//receptionServiceReq.setKrWeight(queryItemMatchResultOptionToAnswerDetailComRespDto.getKrWeight());//SimpleFieldAssign//sourceId:720706_1_31836
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_2!=null){
//      receptionServiceReq.setProcessReportScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_2.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720707_1_31836
//receptionServiceReq.setSubjectiveAndObjectiveScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_2.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720708_1_31836
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_4!=null){
//      receptionServiceReq.setLocalLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_4.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720709_1_31836
//receptionServiceReq.setLowerLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_4.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720710_1_31836
//    }
//
//    /*统一出参[5797]  用于特殊方法接收上游入参。 */
//
//      receptionServiceRes = nbStandardData.implementAccessParameterBizField(receptionServiceReq);
//
//
//      receptionServiceRes_1 = receptionServiceRes;
//           }
//      }
//else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))){
//       //elseif(D3-查询得分权重准备详情(公共).父子中周期类型 等于 中期)  31806
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_6 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_3=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_3.setConfItemCode("MID_PROCESS_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720311_1_31807
//queryItemMatchResultOptionToAnswerDetailComReqDto_3.setResultAspObjType("EVA_TEMP");//sourceId:720313_1_31807
//queryItemMatchResultOptionToAnswerDetailComReqDto_3.setIsPlatData("FALSE");//sourceId:720314_1_31807
//queryItemMatchResultOptionToAnswerDetailComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720316_1_31807
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_3.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720312_1_31807
//    }
//
//    /*D2-3查中期过程汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_6 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_3).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_8 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_4=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_4.setConfItemCode("MID_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720328_1_31808
//queryItemMatchResultOptionToAnswerDetailComReqDto_4.setResultAspObjType("EVA_TEMP");//sourceId:720330_1_31808
//queryItemMatchResultOptionToAnswerDetailComReqDto_4.setIsPlatData("FALSE");//sourceId:720331_1_31808
//queryItemMatchResultOptionToAnswerDetailComReqDto_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720333_1_31808
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_4.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720329_1_31808
//    }
//
//    /*D2-3查中期汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_8 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_4).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_10 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_5=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_5.setConfItemCode("MID_ACTUAL_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720345_1_31809
//queryItemMatchResultOptionToAnswerDetailComReqDto_5.setResultAspObjType("EVA_TEMP");//sourceId:720347_1_31809
//queryItemMatchResultOptionToAnswerDetailComReqDto_5.setIsPlatData("FALSE");//sourceId:720348_1_31809
//queryItemMatchResultOptionToAnswerDetailComReqDto_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720350_1_31809
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_5.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720346_1_31809
//    }
//
//    /*D2-3查中期实际得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_10 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_5).getData();
//
//
//
////ModelCode: receptionService
//        ImplementAccessParameterBizFieldRespDto receptionServiceRes_2 = null;
//    if(queryItemMatchResultOptionToAnswerDetailComRespDto_6 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_8 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_10 !=null){
//          ImplementAccessParameterBizFieldReqDto receptionServiceReq_1=new ImplementAccessParameterBizFieldReqDto();
//  if(queryItemMatchResultOptionToAnswerDetailComRespDto_6!=null){
//      receptionServiceReq_1.setReportAvgScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_6.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720705_1_31838
//receptionServiceReq_1.setKrWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_6.getKrWeight());//SimpleFieldAssign//sourceId:720706_1_31838
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_8!=null){
//      receptionServiceReq_1.setProcessReportScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_8.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720707_1_31838
//receptionServiceReq_1.setSubjectiveAndObjectiveScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_8.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720708_1_31838
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_10!=null){
//      receptionServiceReq_1.setLocalLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_10.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720709_1_31838
//receptionServiceReq_1.setLowerLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_10.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720710_1_31838
//    }
//
//    /*统一出参[5797]  用于特殊方法接收上游入参。 */
//
//      receptionServiceRes_2 = nbStandardData.implementAccessParameterBizField(receptionServiceReq_1);
//
//
//      receptionServiceRes_1 = receptionServiceRes_2;
//           }
//    }
//else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE"))){
//       //elseif(D3-查询得分权重准备详情(公共).父子中周期类型 等于 父周期)  31810
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_12 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_6=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_6.setConfItemCode("FATHER_PROCESS_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720362_1_31811
//queryItemMatchResultOptionToAnswerDetailComReqDto_6.setResultAspObjType("EVA_TEMP");//sourceId:720364_1_31811
//queryItemMatchResultOptionToAnswerDetailComReqDto_6.setIsPlatData("FALSE");//sourceId:720365_1_31811
//queryItemMatchResultOptionToAnswerDetailComReqDto_6.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720367_1_31811
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_6.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720363_1_31811
//    }
//
//    /*D2-3查父周期过程汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_12 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_6).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_14 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_7=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_7.setConfItemCode("FATHER_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720379_1_31812
//queryItemMatchResultOptionToAnswerDetailComReqDto_7.setResultAspObjType("EVA_TEMP");//sourceId:720381_1_31812
//queryItemMatchResultOptionToAnswerDetailComReqDto_7.setIsPlatData("FALSE");//sourceId:720382_1_31812
//queryItemMatchResultOptionToAnswerDetailComReqDto_7.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720384_1_31812
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_7.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720380_1_31812
//    }
//
//    /*D2-3查父周期汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_14 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_7).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_16 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_8=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_8.setConfItemCode("FATHER_ACTUAL_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720396_1_31813
//queryItemMatchResultOptionToAnswerDetailComReqDto_8.setResultAspObjType("EVA_TEMP");//sourceId:720398_1_31813
//queryItemMatchResultOptionToAnswerDetailComReqDto_8.setIsPlatData("FALSE");//sourceId:720399_1_31813
//queryItemMatchResultOptionToAnswerDetailComReqDto_8.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720401_1_31813
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_8.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720397_1_31813
//    }
//
//    /*D2-3查父周期实际得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_8.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查父周期实际得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_8.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查父周期实际得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_8.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查父周期实际得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_16 = confSchemeService.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_8).getData();
//
//
//
////ModelCode: receptionService
//        ImplementAccessParameterBizFieldRespDto receptionServiceRes_3 = null;
//    if(queryItemMatchResultOptionToAnswerDetailComRespDto_12 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_14 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_16 !=null){
//          ImplementAccessParameterBizFieldReqDto receptionServiceReq_2=new ImplementAccessParameterBizFieldReqDto();
//  if(queryItemMatchResultOptionToAnswerDetailComRespDto_12!=null){
//      receptionServiceReq_2.setMidReportWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_12.getMidReportWeight());//SimpleFieldAssign//sourceId:720711_1_31839
//receptionServiceReq_2.setReportAvgScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_12.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720705_1_31839
//receptionServiceReq_2.setKrWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_12.getKrWeight());//SimpleFieldAssign//sourceId:720706_1_31839
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_14!=null){
//      receptionServiceReq_2.setProcessReportScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_14.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720707_1_31839
//receptionServiceReq_2.setSubjectiveAndObjectiveScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_14.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720708_1_31839
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_16!=null){
//      receptionServiceReq_2.setLocalLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_16.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720709_1_31839
//receptionServiceReq_2.setLowerLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_16.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720710_1_31839
//    }
//
//    /*统一出参[5797]  用于特殊方法接收上游入参。 */
//
//      receptionServiceRes_3 = nbStandardData.implementAccessParameterBizField(receptionServiceReq_2);
//
//
//      receptionServiceRes_1 = receptionServiceRes_3;
//           }
//    }
        QueryPrepareForScoreWeightDetailComRespDto retData = new QueryPrepareForScoreWeightDetailComRespDto();
//  if(receptionServiceRes_1!=null){
//      retData.setProcessMidWeight(receptionServiceRes_1.getProcessMidWeight());//SimpleFieldAssign//sourceId:720722_1
//retData.setReportAvgScoreWeight(receptionServiceRes_1.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720723_1
//retData.setKrWeight(receptionServiceRes_1.getKrWeight());//SimpleFieldAssign//sourceId:720724_1
//retData.setProcessReportScoreWeight(receptionServiceRes_1.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720725_1
//retData.setSubjectiveAndObjectiveScoreWeight(receptionServiceRes_1.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720726_1
//retData.setLocalLevelScoreWeight(receptionServiceRes_1.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720727_1
//retData.setLowerLevelScoreWeight(receptionServiceRes_1.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720728_1
//retData.setMidReportWeight(receptionServiceRes_1.getMidReportWeight());//SimpleFieldAssign//sourceId:720729_1
//    }


        return retData;
    }

    /**
     * D3-执行当前及向右分析过程周期（公共）[6067]
     * gen by moon at 4/26/2023, 9:53:46 PM
     */
    @Trace(operationName = "D3-执行当前及向右分析过程周期（公共）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementPercentageGrowthDeclineStandardDataComRespDto implementPercentageGrowthDeclineStandardDataCom(ImplementPercentageGrowthDeclineStandardDataComReqDto reqDto) {


        ImplementFatherCycleTypeAnalysisComRespDto implementFatherCycleTypeAnalysisComRespDto_1 = null;
        ImplementAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage D3-3查当前及向右全量周期类型  32682
        ImplementFatherCycleTypeAnalysisComRespDto implementFatherCycleTypeAnalysisComRespDto = null;
        ImplementFatherCycleTypeAnalysisComReqDto implementFatherCycleTypeAnalysisComReqDto = new ImplementFatherCycleTypeAnalysisComReqDto();
        if (reqDto != null) {
            implementFatherCycleTypeAnalysisComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:754503_1_32682
            implementFatherCycleTypeAnalysisComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:744561_1_32682
            implementFatherCycleTypeAnalysisComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:754477_1_32682
            implementFatherCycleTypeAnalysisComReqDto.setFatherMidSubCycleDataModel(reqDto.getFatherMidSubCycleDataModel());//SimpleFieldAssign//sourceId:744566_1_32682
            implementFatherCycleTypeAnalysisComReqDto.setFatherCycleType(reqDto.getFatherCycleType());//SimpleFieldAssign//sourceId:744559_1_32682
            implementFatherCycleTypeAnalysisComReqDto.setMidCycleType(reqDto.getMidCycleType());//SimpleFieldAssign//sourceId:744560_1_32682
            implementFatherCycleTypeAnalysisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:744558_1_32682
        }

        /*D3-3查当前及向右全量周期类型[5862]   */
        Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getEvaObjTargetCycleId(), "D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-被评对象目标周期ID不能为空", false);
        Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getCycleId(), "D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-周期ID不能为空", false);
        Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getCycleTypeCode(), "D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-周期类型标识不能为空", false);
        Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getFatherCycleType(), "D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-父周期周期类型不能为空", false);
        Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getEvaluationTemplateId(), "D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-冗余评价模板ID不能为空", false);
        implementFatherCycleTypeAnalysisComRespDto = cycleTypeService.implementFatherCycleTypeAnalysisCom(implementFatherCycleTypeAnalysisComReqDto)/*vcase invoke isSameApp*/;


        implementFatherCycleTypeAnalysisComRespDto_1 = implementFatherCycleTypeAnalysisComRespDto;
        if ((implementFatherCycleTypeAnalysisComRespDto != null && implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList() != null && implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList().size() > 0)) {
            //if(D3-3查当前及向右全量周期类型.周期类型列表数据集条数 大于 0)  32683

            QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
            com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto = new QueryConfItemMatchAnswerListComReqDto();
            queryConfItemMatchAnswerListComReqDto.setConfItemCode("PROCESS_STAGE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:744568_1_32684
            queryConfItemMatchAnswerListComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:744569_1_32684
            queryConfItemMatchAnswerListComReqDto.setIsPlatData("FALSE");//sourceId:744571_1_32684
            if (reqDto != null) {
                queryConfItemMatchAnswerListComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:744570_1_32684
            }

            /*D2-3查过程周期类型列表[2505]   */
            Assert.isNull(queryConfItemMatchAnswerListComReqDto.getResultAspObjId(), "D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-答案归属对象ID不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(), "D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerListComReqDto.getResultAspObjType(), "D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-答案归属对象类型不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(), "D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-是否标准答案不能为空", false);
            queryConfItemMatchAnswerListComRespDto = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            ImplementUniteMultipleManyFieldsDataSetsComRespDto implementUniteMultipleManyFieldsDataSetsComRespDto = null;
            if (implementFatherCycleTypeAnalysisComRespDto != null && queryConfItemMatchAnswerListComRespDto != null) {
                ImplementUniteMultipleManyFieldsDataSetsComReqDto implementUniteMultipleManyFieldsDataSetsComReqDto = new ImplementUniteMultipleManyFieldsDataSetsComReqDto();
                if (implementFatherCycleTypeAnalysisComRespDto != null && implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList() != null && !CollectionUtil.isEmpty(implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList())) {
                    implementUniteMultipleManyFieldsDataSetsComReqDto.setDataSetsListOne(//objList-to-objLists
                            implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList().stream().map(item -> {
                                com.wicket.okrcomponent.integration.dto.DataSetsListOneDto elm = new com.wicket.okrcomponent.integration.dto.DataSetsListOneDto();
                                if (item != null) {
                                    elm.setCustomField(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:168063_2_32685
                                    elm.setComTxtField(item.getOrderNumber() != null ? String.valueOf(item.getOrderNumber()) : "");//SimpleFieldAssign//sourceId:168064_2_32685
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:744586_1_32685
                }
                if (queryConfItemMatchAnswerListComRespDto != null && queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() != null && !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())) {
                    implementUniteMultipleManyFieldsDataSetsComReqDto.setDataSetsListTwo(//objList-to-objLists
                            queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item -> {
                                DataSetsListTwoDto elm = new DataSetsListTwoDto();
                                if (item != null) {
                                    elm.setCustomField(item.getEndValue());//SimpleFieldAssign//sourceId:168065_2_32685
                                    elm.setCustomField1(item.getConfOptionSortNum() != null ? String.valueOf(item.getConfOptionSortNum()) : "");//SimpleFieldAssign//sourceId:168066_2_32685
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:744587_1_32685
                }

                /*D2-筛选向右过程周期类型[5676]   */

                implementUniteMultipleManyFieldsDataSetsComRespDto = interfaceModeService.implementUniteMultipleManyFieldsDataSetsCom(implementUniteMultipleManyFieldsDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementUniteMultipleManyFieldsDataSetsComRespDto != null && implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList() != null && implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList().size() > 0)) {
                //if(D2-筛选向右过程周期类型.数据集交集列表数据集条数 大于 0)  32686

                List<OmsCycle> listOmsCycle = new ArrayList<>();
                if (implementUniteMultipleManyFieldsDataSetsComRespDto != null && implementFatherCycleTypeAnalysisComRespDto != null) {
                    BatchQueryRightProcessCycleByCodeListByCodesReq batchQueryRightProcessCycleByCodeListByCodesReq = new BatchQueryRightProcessCycleByCodeListByCodesReq();
                    batchQueryRightProcessCycleByCodeListByCodesReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:745707_1_32713
                    if (implementUniteMultipleManyFieldsDataSetsComRespDto != null && implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList() != null && !CollectionUtil.isEmpty(implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList())) {
                        batchQueryRightProcessCycleByCodeListByCodesReq.setCycleList(implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList().stream().map(item -> item.getCustomField())
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:745704_1_32713
                    }
                    if (implementFatherCycleTypeAnalysisComRespDto != null) {
                        batchQueryRightProcessCycleByCodeListByCodesReq.setCycleStartTime(implementFatherCycleTypeAnalysisComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:745705_1_32713
                        batchQueryRightProcessCycleByCodeListByCodesReq.setCycleEndTime(implementFatherCycleTypeAnalysisComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:745706_1_32713
                    }

                    /*3-4-04查询向右过程周期列表ByCodes[6070]   */
                    Assert.isNull(batchQueryRightProcessCycleByCodeListByCodesReq.getCycleStartTime(), "D3-执行当前及向右分析过程周期（公共）-3-4-04查询向右过程周期列表ByCodes-周期开始时间不能为空", false);
                    Assert.isNull(batchQueryRightProcessCycleByCodeListByCodesReq.getCycleEndTime(), "D3-执行当前及向右分析过程周期（公共）-3-4-04查询向右过程周期列表ByCodes-周期结束时间不能为空", false);
                    Assert.isNull(batchQueryRightProcessCycleByCodeListByCodesReq.getSubjectLifeCycle(), "D3-执行当前及向右分析过程周期（公共）-3-4-04查询向右过程周期列表ByCodes-主体生命周期不能为空", false);
                    listOmsCycle = mOmsCycleService.batchQueryRightProcessCycleByCodeListByCodes(batchQueryRightProcessCycleByCodeListByCodesReq)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: receptionService
                ImplementAcceptAboveFieldsRespDto receptionServiceRes = null;
                if (listOmsCycle != null && !CollectionUtil.isEmpty(listOmsCycle) && listOmsCycle.size() > 0) {
                    ImplementAcceptAboveFieldsReqDto receptionServiceReq = new ImplementAcceptAboveFieldsReqDto();
                    if (listOmsCycle != null && !CollectionUtil.isEmpty(listOmsCycle) && listOmsCycle != null && !CollectionUtil.isEmpty(listOmsCycle)) {
                        receptionServiceReq.setProcessExceuteCycleStageList(//objList-to-objLists
                                listOmsCycle.stream().map(item -> {
                                    ProcessExceuteCycleStageDto elm = new ProcessExceuteCycleStageDto();
                                    elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:168119_2_32705
                                    if (reqDto != null) {
                                        elm.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:168120_2_32705
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:744969_1_32705
                    }

                    /*M3-将过程周期ID与目标周期ID合并成数据集[5897]  用于特殊方法接收上游入参。 */

                    receptionServiceRes = nbStandardData.implementAcceptAboveFields(receptionServiceReq);


                    receptionServiceRes_1 = receptionServiceRes;
                }
            }
        }
        ImplementPercentageGrowthDeclineStandardDataComRespDto retData = new ImplementPercentageGrowthDeclineStandardDataComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setProcessExceuteCycleStageList(receptionServiceRes_1.getProcessExceuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ProcessExceuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:745938_1
        }
        if (implementFatherCycleTypeAnalysisComRespDto_1 != null) {
            retData.setLastEvaObjTargetCycleId(implementFatherCycleTypeAnalysisComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:754790_1
            retData.setLastCycleId(implementFatherCycleTypeAnalysisComRespDto_1.getLastCycleId());//SimpleFieldAssign//sourceId:754791_1
        }


        return retData;
    }

    /**
     * 1111D3-执行提交汇报任务异常校验(公共)[6159]
     * gen by moon at 3/28/2023, 10:17:33 AM
     */
    @Trace(operationName = "1111D3-执行提交汇报任务异常校验(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCommitTaskReportCheckComRespDto implementCommitTaskReportCheckCom(ImplementCommitTaskReportCheckComReqDto reqDto) {


        //virtualUsage 3-3-09-03查询评价模板批次设置详情  35045
        OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
        QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq = new QueryPlanEvaBatchSetDetailReq();
        queryPlanEvaBatchSetDetailReq.setBatchSetObjectType("TOP_EVA_TEMP_MGT");//sourceId:787430_1_35045
        if (reqDto != null) {
            queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:787429_1_35045
        }

        /*3-3-09-03查询评价模板批次设置详情[2998]   */
        Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(), "1111D3-执行提交汇报任务异常校验(公共)-3-3-09-03查询评价模板批次设置详情-批次设置对象ID不能为空", false);
        Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetObjectType(), "1111D3-执行提交汇报任务异常校验(公共)-3-3-09-03查询评价模板批次设置详情-批次设置对象类型不能为空", false);
        omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((!(omsEvaBatchRelatedSet != null && omsEvaBatchRelatedSet.getUsingLockStatus() != null && omsEvaBatchRelatedSet.getUsingLockStatus().equals("UNLOCK")))) {
            //if(3-3-09-03查询评价模板批次设置详情.使用锁定状态 不等于 未锁定)  35046

//异常结束 35047
            throw new BizException("B10000043", "对不起，该批次已锁定，请稍后重试！", false);
        }
        ImplementCommitTaskReportCheckComRespDto retData = new ImplementCommitTaskReportCheckComRespDto();


        return retData;
    }

    /**
     * D3-查朋友圈列表标准数据(公共)[6277]
     * gen by moon at 9/29/2024, 3:29:59 PM
     */
    @Trace(operationName = "D3-查朋友圈列表标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryHighMidBaseStandardDataByStageDataDetailComRespDto queryHighMidBaseStandardDataByStageDataDetailCom(QueryHighMidBaseStandardDataByStageDataDetailComReqDto reqDto) {


        ImplementAccessParameterBizFieldRespDto receptionServiceRes_1 = null;
//virtualUsage D4-查询通过周期阶段资料过滤后标准数据列表(公共)  73056
        QueryFiltrationStandardDataByStageDataListComRespDto queryFiltrationStandardDataByStageDataListComRespDto = null;
        QueryFiltrationStandardDataByStageDataListComReqDto queryFiltrationStandardDataByStageDataListComReqDto = new QueryFiltrationStandardDataByStageDataListComReqDto();
        if (reqDto != null) {
            queryFiltrationStandardDataByStageDataListComReqDto.setCycleStageDataList(reqDto.getCycleStageDataList());//list-field-assign//sourceId:826273_1_73056
            queryFiltrationStandardDataByStageDataListComReqDto.setIsNewData(reqDto.getIsNewData());//SimpleFieldAssign//sourceId:857571_1_73056
            queryFiltrationStandardDataByStageDataListComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:2012101_1_73056
            queryFiltrationStandardDataByStageDataListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:826770_1_73056
        }

        /*D4-查询通过周期阶段资料过滤后标准数据列表(公共)[4543]   */
        Assert.isNull(queryFiltrationStandardDataByStageDataListComReqDto.getIsNewData(), "D3-查朋友圈列表标准数据(公共)-D4-查询通过周期阶段资料过滤后标准数据列表(公共)-是否归属周期最新数据不能为空", false);
        Assert.isNull(queryFiltrationStandardDataByStageDataListComReqDto.getExtendedField3(), "D3-查朋友圈列表标准数据(公共)-D4-查询通过周期阶段资料过滤后标准数据列表(公共)-扩展字段3不能为空", false);
        Assert.isNull(queryFiltrationStandardDataByStageDataListComReqDto.getThemeContentId(), "D3-查朋友圈列表标准数据(公共)-D4-查询通过周期阶段资料过滤后标准数据列表(公共)-主题内容ID不能为空", false);
        queryFiltrationStandardDataByStageDataListComRespDto = fwCalcStandardDataClient.queryFiltrationStandardDataByStageDataListCom(queryFiltrationStandardDataByStageDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage M3-约定出参：标准数据列表  73057
//ModelCode: receptionService
        ImplementAccessParameterBizFieldRespDto receptionServiceRes = null;
        if (queryFiltrationStandardDataByStageDataListComRespDto != null) {
            ImplementAccessParameterBizFieldReqDto receptionServiceReq = new ImplementAccessParameterBizFieldReqDto();
            if (queryFiltrationStandardDataByStageDataListComRespDto != null && queryFiltrationStandardDataByStageDataListComRespDto.getStandardDataList() != null && !CollectionUtil.isEmpty(queryFiltrationStandardDataByStageDataListComRespDto.getStandardDataList())) {
                receptionServiceReq.setStandardDataList(queryFiltrationStandardDataByStageDataListComRespDto.getStandardDataList().stream().map(item -> BeanUtil.toBean(item, StandardDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:826647_1_73057
            }

            /*M3-约定出参：标准数据列表[5797]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbStandardData.implementAccessParameterBizField(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        }
        QueryHighMidBaseStandardDataByStageDataDetailComRespDto retData = new QueryHighMidBaseStandardDataByStageDataDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setStandardDataList(receptionServiceRes_1.getStandardDataList().stream().map(item -> BeanUtil.toBean(item, StandardDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:826649_1
        }


        return retData;
    }

    /**
     * D3-执行提交标准数据准备(公共)[7023]
     * gen by moon at 3/13/2024, 5:22:01 AM
     */
    @Trace(operationName = "D3-执行提交标准数据准备(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementReadyForCommitStandardDataComRespDto implementReadyForCommitStandardDataCom(ImplementReadyForCommitStandardDataComReqDto reqDto) {


        QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto_1 = null;
        ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto_1 = null;
        QueryTargetContentAndExtendInfoDetailComRespDto queryTargetContentAndExtendInfoDetailComRespDto_1 = null;
        AnalysisCurStandardDataCalcCycleModelComRespDto analysisCurStandardDataCalcCycleModelComRespDto_1 = null;
        ImplementAnalyseWorkCycleUpdateSliceComRespDto implementAnalyseWorkCycleUpdateSliceComRespDto_1 = null;
        ImplementIsWorkCycleDataAnalysisComRespDto implementIsWorkCycleDataAnalysisComRespDto_1 = null;
        ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto_1 = null;
//步骤0: M3-计算接收上文字段（特殊方法） - calculateAcceptAboveFields
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:995962_1
            receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:995963_1
            receptionServiceReq.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514136_1
            receptionServiceReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1212380_1
            receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:995978_1
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:996079_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:995960_1
        }

        /*M3-接收入参字段[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3-执行提交标准数据准备(公共)-M3-接收入参字段-被评对象目标周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getCycleId(), "D3-执行提交标准数据准备(公共)-M3-接收入参字段-周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(), "D3-执行提交标准数据准备(公共)-M3-接收入参字段-关联目标内容类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3-执行提交标准数据准备(公共)-M3-接收入参字段-关联目标内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-M3-接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbStandardData.calculateAcceptAboveFields(receptionServiceReq);


//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1167905_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1167903_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1167904_1
        }

        /*3-3-09查被评对象目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行提交标准数据准备(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3-执行提交标准数据准备(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤2: D3-查询上一个执行周期的周期及目标周期详情(公共) - queryLastExecCycleAndTargetCycleDetailCom
        QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
        QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto = new QueryLastExecCycleAndTargetCycleDetailComReqDto();
        if (reqDto != null) {
            queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1167909_1
            queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1167910_1
            queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1167911_1
        }

        /*D3-查询上一执行周期目标周期&周期ID[7507]   */
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(), "D3-执行提交标准数据准备(公共)-D3-查询上一执行周期目标周期&周期ID-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(), "D3-执行提交标准数据准备(公共)-D3-查询上一执行周期目标周期&周期ID-周期ID不能为空", false);
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-D3-查询上一执行周期目标周期&周期ID-冗余评价模板ID不能为空", false);
        queryLastExecCycleAndTargetCycleDetailComRespDto = executeCycleService.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


        queryLastExecCycleAndTargetCycleDetailComRespDto_1 = queryLastExecCycleAndTargetCycleDetailComRespDto;

//步骤3: D3执行内容类型互转表类型(公共) - implementContentTypeChangeTableTypeCom
        ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
        ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto = new ImplementContentTypeChangeTableTypeComReqDto();
        if (reqDto != null) {
            implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:995973_1
        }

        /*D3执行内容类型互转表类型(公共)[5354]   */

        implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


        implementContentTypeChangeTableTypeComRespDto_1 = implementContentTypeChangeTableTypeComRespDto;

//步骤4: D3-查询目标内容及目标内容扩展信息（本级无实际值标识） - queryTargetContentAndExtendInfoDetailCom
        QueryTargetContentAndExtendInfoDetailComRespDto queryTargetContentAndExtendInfoDetailComRespDto = null;
        QueryTargetContentAndExtendInfoDetailComReqDto queryTargetContentAndExtendInfoDetailComReqDto = new QueryTargetContentAndExtendInfoDetailComReqDto();
        if (reqDto != null) {
            queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:996064_1
            queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:996065_1
            queryTargetContentAndExtendInfoDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:996066_1
        }

        /*D3-查目标内容一级目标分类[6148]   */
        Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentTypeCode(), "D3-执行提交标准数据准备(公共)-D3-查目标内容一级目标分类-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentId(), "D3-执行提交标准数据准备(公共)-D3-查目标内容一级目标分类-关联目标内容ID不能为空", false);
        Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-D3-查目标内容一级目标分类-冗余评价模板ID不能为空", false);
        queryTargetContentAndExtendInfoDetailComRespDto = targetContentService.queryTargetContentAndExtendInfoDetailCom(queryTargetContentAndExtendInfoDetailComReqDto)/*vcase invoke isSameApp*/;


        queryTargetContentAndExtendInfoDetailComRespDto_1 = queryTargetContentAndExtendInfoDetailComRespDto;

//步骤5: 3-3-07查询执行周期阶段详情 - queryExecuteCycleStageDetail
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
        queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:996057_1
        if (reqDto != null) {
            queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:996055_1
            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:996056_1
        }

        /*3-3-07查询执行周期阶段详情[2429]   */
        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3-执行提交标准数据准备(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3-执行提交标准数据准备(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤6: D2-查询周期类型配置详情(公共) - queryCycleTypeConfDetailCom
        QueryCycleTypeConfDetailComRespDto queryCycleTypeConfDetailComRespDto = null;
        QueryCycleTypeConfDetailComReqDto queryCycleTypeConfDetailComReqDto = new QueryCycleTypeConfDetailComReqDto();
        if (reqDto != null) {
            queryCycleTypeConfDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1578562_1
        }

        /*D2-查询周期类型配置详情(公共)[8581]   */
        Assert.isNull(queryCycleTypeConfDetailComReqDto.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-D2-查询周期类型配置详情(公共)-冗余评价模板ID不能为空", false);
        queryCycleTypeConfDetailComRespDto = fwCompStandardDataClient.queryCycleTypeConfDetailCom(queryCycleTypeConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤7: D3分析目标归属周期计算周期五模型当前模型(公共) - analysisCurStandardDataCalcCycleModelCom
        AnalysisCurStandardDataCalcCycleModelComRespDto analysisCurStandardDataCalcCycleModelComRespDto = null;
        if (queryCycleTypeConfDetailComRespDto != null) {
            AnalysisCurStandardDataCalcCycleModelComReqDto analysisCurStandardDataCalcCycleModelComReqDto = new AnalysisCurStandardDataCalcCycleModelComReqDto();
            if (queryCycleTypeConfDetailComRespDto != null) {
                analysisCurStandardDataCalcCycleModelComReqDto.setPeriodicModeTypeCode(queryCycleTypeConfDetailComRespDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1577642_1
                analysisCurStandardDataCalcCycleModelComReqDto.setSubcycleType(queryCycleTypeConfDetailComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1577634_1
                analysisCurStandardDataCalcCycleModelComReqDto.setLastCycleType(queryCycleTypeConfDetailComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1577635_1
                analysisCurStandardDataCalcCycleModelComReqDto.setSecondLastCycleType(queryCycleTypeConfDetailComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1577636_1
            }
            if (reqDto != null) {
                analysisCurStandardDataCalcCycleModelComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1577631_1
                analysisCurStandardDataCalcCycleModelComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1577637_1
            }
            if (omsExecuteCycleStage != null) {
                analysisCurStandardDataCalcCycleModelComReqDto.setUpdateCycleTypeCode(omsExecuteCycleStage.getCycleTypeCode());//SimpleFieldAssign//sourceId:1577632_1
                analysisCurStandardDataCalcCycleModelComReqDto.setUpdateCycleEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:1577633_1
            }

            /*D3分析目标归属周期计算周期五模型当前模型(公共)[8574]   */
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getPeriodicModeTypeCode(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-周期模式类型编码不能为空", false);
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getSubcycleType(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-子周期周期类型不能为空", false);
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getLastCycleType(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-末级周期类型不能为空", false);
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getEvaObjTargetCycleId(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getUpdateCycleTypeCode(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getUpdateCycleEndTime(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getEvaluationTemplateId(), "D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-冗余评价模板ID不能为空", false);
            analysisCurStandardDataCalcCycleModelComRespDto = targetCalcService.analysisCurStandardDataCalcCycleModelCom(analysisCurStandardDataCalcCycleModelComReqDto)/*vcase invoke isSameApp*/;


            analysisCurStandardDataCalcCycleModelComRespDto_1 = analysisCurStandardDataCalcCycleModelComRespDto;
        }

//步骤8: D3-执行分析工作周期更新切片（公共） - implementAnalyseWorkCycleUpdateSliceCom
        ImplementAnalyseWorkCycleUpdateSliceComRespDto implementAnalyseWorkCycleUpdateSliceComRespDto = null;
        if (omsExecuteCycleStage != null) {
            ImplementAnalyseWorkCycleUpdateSliceComReqDto implementAnalyseWorkCycleUpdateSliceComReqDto = new ImplementAnalyseWorkCycleUpdateSliceComReqDto();
            if (omsExecuteCycleStage != null) {
                implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleStartTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:996083_1
                implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:996086_1
            }
            if (reqDto != null) {
                implementAnalyseWorkCycleUpdateSliceComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:996084_1
            }

            /*D3-执行分析工作周期更新切片[6275]   */
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleStartTime(), "D3-执行提交标准数据准备(公共)-D3-执行分析工作周期更新切片-目标计划开始时间不能为空", false);
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleEndTime(), "D3-执行提交标准数据准备(公共)-D3-执行分析工作周期更新切片-目标计划结束时间不能为空", false);
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getEvaObjTargetCycleId(), "D3-执行提交标准数据准备(公共)-D3-执行分析工作周期更新切片-被评对象目标周期ID不能为空", false);
            implementAnalyseWorkCycleUpdateSliceComRespDto = cycleStageDataService.implementAnalyseWorkCycleUpdateSliceCom(implementAnalyseWorkCycleUpdateSliceComReqDto)/*vcase invoke isSameApp*/;


            implementAnalyseWorkCycleUpdateSliceComRespDto_1 = implementAnalyseWorkCycleUpdateSliceComRespDto;
        }

//步骤9: D3-执行分析是否工作周期数据(公共) - implementIsWorkCycleDataAnalysisCom
        ImplementIsWorkCycleDataAnalysisComRespDto implementIsWorkCycleDataAnalysisComRespDto = null;
        if (analysisCurStandardDataCalcCycleModelComRespDto != null) {
            ImplementIsWorkCycleDataAnalysisComReqDto implementIsWorkCycleDataAnalysisComReqDto = new ImplementIsWorkCycleDataAnalysisComReqDto();
            if (analysisCurStandardDataCalcCycleModelComRespDto != null) {
                implementIsWorkCycleDataAnalysisComReqDto.setStandardDataCalcCycleModel(analysisCurStandardDataCalcCycleModelComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1084863_1
            }

            /*D3-执行分析是否工作周期数据(公共)[7294]   */
            Assert.isNull(implementIsWorkCycleDataAnalysisComReqDto.getStandardDataCalcCycleModel(), "D3-执行提交标准数据准备(公共)-D3-执行分析是否工作周期数据(公共)-标准数据计算周期模型不能为空", false);
            implementIsWorkCycleDataAnalysisComRespDto = implementIsWorkCycleDataAnalysisCom(implementIsWorkCycleDataAnalysisComReqDto)/*vcase invoke 同服务,同domain*/;


            implementIsWorkCycleDataAnalysisComRespDto_1 = implementIsWorkCycleDataAnalysisComRespDto;
        }

//步骤10: D3准备相关人入参数据(公共) - implementStandardDataFillRoleInfoCom
        ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto = null;
        ImplementStandardDataFillRoleInfoComReqDto implementStandardDataFillRoleInfoComReqDto = new ImplementStandardDataFillRoleInfoComReqDto();
        implementStandardDataFillRoleInfoComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1514436_1
        if (reqDto != null) {
            implementStandardDataFillRoleInfoComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1514431_1
            implementStandardDataFillRoleInfoComReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514430_1
            implementStandardDataFillRoleInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514432_1
        }

        /*D3准备相关人入参数据(公共)[8371]   */
        Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getTargetCycleContentId(), "D3-执行提交标准数据准备(公共)-D3准备相关人入参数据(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getUseScene(), "D3-执行提交标准数据准备(公共)-D3准备相关人入参数据(公共)-虚拟组织使用场景不能为空", false);
        implementStandardDataFillRoleInfoComRespDto = virtualOrgService.implementStandardDataFillRoleInfoCom(implementStandardDataFillRoleInfoComReqDto)/*vcase invoke isSameApp*/;


        implementStandardDataFillRoleInfoComRespDto_1 = implementStandardDataFillRoleInfoComRespDto;

        ImplementReadyForCommitStandardDataComRespDto retData = new ImplementReadyForCommitStandardDataComRespDto();
        if (queryLastExecCycleAndTargetCycleDetailComRespDto_1 != null) {
            retData.setLastEvaObjTargetCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1167918_1
            retData.setLastCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastCycleId());//SimpleFieldAssign//sourceId:1167919_1
        }
        if (implementContentTypeChangeTableTypeComRespDto_1 != null) {
            retData.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:996142_1
        }
        if (queryTargetContentAndExtendInfoDetailComRespDto_1 != null) {
            retData.setRootTargetCategoryId(queryTargetContentAndExtendInfoDetailComRespDto_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:996144_1
        }
        if (implementAnalyseWorkCycleUpdateSliceComRespDto_1 != null) {
            retData.setWorkCycleUpdateSlice(implementAnalyseWorkCycleUpdateSliceComRespDto_1.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:996145_1
        }
        if (implementIsWorkCycleDataAnalysisComRespDto_1 != null) {
            retData.setIsWorkCycleData(implementIsWorkCycleDataAnalysisComRespDto_1.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1084865_1
        }
        if (analysisCurStandardDataCalcCycleModelComRespDto_1 != null) {
            retData.setStandardDataCalcCycleModel(analysisCurStandardDataCalcCycleModelComRespDto_1.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1578711_1
        }
        if (implementStandardDataFillRoleInfoComRespDto_1 != null) {
            retData.setBizRoleObjId(implementStandardDataFillRoleInfoComRespDto_1.getRoleId());//SimpleFieldAssign//sourceId:1514947_1
            retData.setBizRoleObjCode(implementStandardDataFillRoleInfoComRespDto_1.getRoleCode());//SimpleFieldAssign//sourceId:1514948_1
            retData.setBizRoleObjName(implementStandardDataFillRoleInfoComRespDto_1.getRoleName());//SimpleFieldAssign//sourceId:1514949_1
            retData.setVirtualOrgInductionRecordId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514946_1
            retData.setVirtualOrgMemberId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgMemberId());//SimpleFieldAssign//sourceId:1557368_1
        }


        return retData;
    }

    /**
     * D3-执行分析是否工作周期数据(公共)[7294]
     * gen by moon at 7/10/2023, 1:49:05 AM
     */
    @Trace(operationName = "D3-执行分析是否工作周期数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementIsWorkCycleDataAnalysisComRespDto implementIsWorkCycleDataAnalysisCom(ImplementIsWorkCycleDataAnalysisComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
//virtualUsage 约定：是  47431
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setTureOrFalse("TRUE");//sourceId:1084855_1_47431

        /*约定：是[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-执行分析是否工作周期数据(公共)-约定：是-是否不能为空", false);
        receptionServiceRes = nbStandardData.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：否  47432
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:1084856_1_47432

        /*约定：否[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-执行分析是否工作周期数据(公共)-约定：否-是否不能为空", false);
        receptionServiceRes_2 = nbStandardData.calculateAcceptAboveFields(receptionServiceReq_1);


        if ((reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("LAST_CYCLE") || reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("MID_OF_PROCESS_CYCLE"))) {
            //if((D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 末级周期 or D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 中间周期))  47430

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_2.setIsWorkCycleData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:1084859_1_47433
            }

            /*约定出参：是否工作周期数据[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes_4 = nbStandardData.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_5 = receptionServiceRes_4;
        } else if ((reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("SUB_CYCLE") || reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("MID_CYCLE") || reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("PARENT_CYCLE"))) {
            //elseif((D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 子周期 or D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 中期 or D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 父周期))  47434

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_3.setIsWorkCycleData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:1084859_1_47435
            }

            /*约定出参：是否工作周期数据[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes_6 = nbStandardData.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_5 = receptionServiceRes_6;
        }
        ImplementIsWorkCycleDataAnalysisComRespDto retData = new ImplementIsWorkCycleDataAnalysisComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setIsWorkCycleData(receptionServiceRes_5.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1084862_1
        }


        return retData;
    }

    /**
     * D3执行增目标内容预算标准数据(公共)[7729]
     * gen by moon at 1/31/2024, 8:43:33 PM
     */
    @Trace(operationName = "D3执行增目标内容预算标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAddTargetCycleBudgetStandardDataComRespDto implementAddTargetCycleBudgetStandardDataCom(ImplementAddTargetCycleBudgetStandardDataComReqDto reqDto) {


        //virtualUsage D7-查当前内容资金账户详请（用于新增标准数据使用）  60389
        QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
        QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto = new QueryFinanceAccountDetailComReqDto();
        queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1512646_1_60389
        queryFinanceAccountDetailComReqDto.setIsArchive("FALSE");//sourceId:1512649_1_60389
        queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1512650_1_60389
        if (reqDto != null) {
            queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1512648_1_60389
        }

        /*D7-查当前内容资金账户详请（用于新增标准数据使用）[7681]   */
        Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(), "D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-关联归属主体ID不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(), "D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-是否预算账户不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto.getIsArchive(), "D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-是否存档不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(), "D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-创建于空间ID不能为空", false);
        queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        //virtualUsage 3-3-09查当前内容目标子周期列表  52077
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq = new QueryEvaObjTargetCycleListReq();
        queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1247160_1_52077
        queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1247162_1_52077
        if (reqDto != null) {
            queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247158_1_52077
            queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247159_1_52077
            queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247161_1_52077
        }

        /*3-3-09查当前内容目标子周期列表[2190]   */
        Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-是否存档不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsEvaluationObjectTargetCycle != null && listOmsEvaluationObjectTargetCycle != null && listOmsEvaluationObjectTargetCycle.size() > 0)) {
            //if(3-3-09查当前内容目标子周期列表.被评对象目标周期列表数据集条数 大于 0)  52079

            ImplementLoopAddTargetSubCycleBudgetDataComRespDto implementLoopAddTargetSubCycleBudgetDataComRespDto = null;
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0 && queryFinanceAccountDetailComRespDto != null) {
                ImplementLoopAddTargetSubCycleBudgetDataComReqDto implementLoopAddTargetSubCycleBudgetDataComReqDto = new ImplementLoopAddTargetSubCycleBudgetDataComReqDto();
                if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.integration.dto.EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1247093_1_52080
                }
                if (queryFinanceAccountDetailComRespDto != null) {
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513207_1_52080
                }
                if (reqDto != null) {
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247094_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1247096_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1247095_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247092_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1247097_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511485_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511486_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511487_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511488_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511489_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511490_1_52080
                    implementLoopAddTargetSubCycleBudgetDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511491_1_52080
                }

                /*D4执行循环增目标子周期预算标准数据(公共)[7717]   */
                Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getAccountId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-归属账户ID不能为空", false);
                Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getUnit(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-冗余单位不能为空", false);
                Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getResultType(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-结果产生类型 不能为空", false);
                Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getParentSubMidCycleType(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-父子中周期类型不能为空", false);
                implementLoopAddTargetSubCycleBudgetDataComRespDto = fwCalcStandardDataClient.implementLoopAddTargetSubCycleBudgetDataCom(implementLoopAddTargetSubCycleBudgetDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
//virtualUsage D2执行资金来源数据集去重  52089
        ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto = null;
        ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto = new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
        if (reqDto != null) {
            //simpleList-to-objLists
            for (String item : reqDto.getEvaObjTargetCycleList()) {
                DataSetDuplicateRemovalDto oneItem = new DataSetDuplicateRemovalDto();
                if (reqDto != null) {
                    oneItem.setCommPrimaryKey(item);//SimpleFieldAssign//sourceId:257088_2_52089
                }

                implementManyFieldsDataSetDuplicateRemovalComReqDto.getDataSetDuplicateRemovalList().add(oneItem);
            }//sourceId:1247509_1_52089
        }

        /*D2执行资金来源数据集去重[7323]   */

        implementManyFieldsDataSetDuplicateRemovalComRespDto = interfaceModeService.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage 3-3-09查当前内容目标父周期  52081
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1247337_1_52081
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1247339_1_52081
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247335_1_52081
            queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247336_1_52081
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247338_1_52081
        }

        /*3-3-09查当前内容目标父周期[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsEvaluationObjectTargetCycle != null)) {
            //if(3-3-09查当前内容目标父周期.出参 值不等于空 )  52082

            ImplementAddTargetParentMidCycleBudgetDataComRespDto implementAddTargetParentMidCycleBudgetDataComRespDto = null;
            if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && queryFinanceAccountDetailComRespDto != null && omsEvaluationObjectTargetCycle != null) {
                ImplementAddTargetParentMidCycleBudgetDataComReqDto implementAddTargetParentMidCycleBudgetDataComReqDto = new ImplementAddTargetParentMidCycleBudgetDataComReqDto();
                implementAddTargetParentMidCycleBudgetDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1247107_1_52083
                implementAddTargetParentMidCycleBudgetDataComReqDto.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1247111_1_52083
                if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() != null && !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())) {
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setEvaObjTargetCycleList(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item -> item.getCommPrimaryKey())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1247098_1_52083
                }
                if (queryFinanceAccountDetailComRespDto != null) {
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513216_1_52083
                }
                if (reqDto != null) {
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247106_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1247108_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1247110_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247112_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247099_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleMode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1247109_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511384_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setPersonLiableTypeCode(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511385_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511386_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511387_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511388_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511389_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511390_1_52083
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1247100_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1247101_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1247102_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1247103_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleTypeCode(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1247104_1_52083
                    implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1247105_1_52083
                }

                /*D4执行目标父周期预算标准数据(公共)[7724]   */
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getAccountId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-归属账户ID不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getUnit(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-冗余单位不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getResultType(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-结果产生类型 不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getBelongToContentTypeCode(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getBelongToContentId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getEvaObjTargetCycleId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期ID不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleStartTime(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期开始时间不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleEndTime(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期结束时间不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleTypeCode(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期类型标识不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleMode(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期模式不能为空", false);
                Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getParentSubMidCycleType(), "D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-父子中周期类型不能为空", false);
                implementAddTargetParentMidCycleBudgetDataComRespDto = fwCalcStandardDataClient.implementAddTargetParentMidCycleBudgetDataCom(implementAddTargetParentMidCycleBudgetDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        if ((reqDto != null && reqDto.getPeriodicModeTypeCode() != null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE") && reqDto != null && reqDto.getOpenMidCycle() != null && reqDto.getOpenMidCycle().equals("TRUE"))) {
            //if((D3执行增目标内容预算标准数据(公共).周期模式类型编码 等于 父子周期 and D3执行增目标内容预算标准数据(公共).是否开启中期 等于 是))  52092

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_1.setIsMetaphase("TRUE");//sourceId:1247324_1_52093
            queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1247326_1_52093
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247322_1_52093
                queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247323_1_52093
                queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247325_1_52093
            }

            /*3-3-09查当前内容目标中期[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsMetaphase(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-是否中期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsEvaluationObjectTargetCycle_2 != null)) {
                //if(3-3-09查当前内容目标中期.出参 值不等于空 )  52094

                ImplementAddTargetParentMidCycleBudgetDataComRespDto implementAddTargetParentMidCycleBudgetDataComRespDto_1 = null;
                if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && queryFinanceAccountDetailComRespDto != null && omsEvaluationObjectTargetCycle_2 != null) {
                    ImplementAddTargetParentMidCycleBudgetDataComReqDto implementAddTargetParentMidCycleBudgetDataComReqDto_1 = new ImplementAddTargetParentMidCycleBudgetDataComReqDto();
                    implementAddTargetParentMidCycleBudgetDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1247122_1_52097
                    implementAddTargetParentMidCycleBudgetDataComReqDto_1.setParentSubMidCycleType("MID_CYCLE");//sourceId:1247126_1_52097
                    if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() != null && !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())) {
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setEvaObjTargetCycleList(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item -> item.getCommPrimaryKey())
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:1247113_1_52097
                    }
                    if (queryFinanceAccountDetailComRespDto != null) {
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513239_1_52097
                    }
                    if (reqDto != null) {
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247121_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1247123_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1247125_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247127_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247114_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleMode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1247124_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511416_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511417_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511418_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511419_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511420_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511421_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511422_1_52097
                    }
                    if (omsEvaluationObjectTargetCycle_2 != null) {
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1247115_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleId(omsEvaluationObjectTargetCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1247116_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleStartTime(omsEvaluationObjectTargetCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1247117_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleEndTime(omsEvaluationObjectTargetCycle_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1247118_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleTypeCode(omsEvaluationObjectTargetCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1247119_1_52097
                        implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1247120_1_52097
                    }

                    /*D4执行目标中周期预算标准数据(公共)[7724]   */
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getAccountId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-归属账户ID不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getUnit(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-冗余单位不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getResultType(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-结果产生类型 不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getBelongToContentTypeCode(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-数据归属内容表类型编码不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getBelongToContentId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-数据归属内容表主键ID不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getEvaObjTargetCycleId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期ID不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleStartTime(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期开始时间不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleEndTime(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期结束时间不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleTypeCode(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期类型标识不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getParentSubMidCycleType(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-父子中周期类型不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleMode(), "D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期模式不能为空", false);
                    implementAddTargetParentMidCycleBudgetDataComRespDto_1 = fwCalcStandardDataClient.implementAddTargetParentMidCycleBudgetDataCom(implementAddTargetParentMidCycleBudgetDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
            }
        }
//virtualUsage D4执行循环增目标子周期预算占比标准数据(公共)  54639
        ImplementLoopAddSubCycleBudgetPropStandardDataComRespDto implementLoopAddSubCycleBudgetPropStandardDataComRespDto = null;
        if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0 && queryFinanceAccountDetailComRespDto != null && omsEvaluationObjectTargetCycle != null) {
            ImplementLoopAddSubCycleBudgetPropStandardDataComReqDto implementLoopAddSubCycleBudgetPropStandardDataComReqDto = new ImplementLoopAddSubCycleBudgetPropStandardDataComReqDto();
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.integration.dto.EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1354048_1_54639
            }
            if (queryFinanceAccountDetailComRespDto != null) {
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513222_1_54639
            }
            if (reqDto != null) {
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1354053_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1354054_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1354050_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1354051_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511445_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511446_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511447_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511448_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511449_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511450_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511451_1_54639
            }
            if (omsEvaluationObjectTargetCycle != null) {
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1354049_1_54639
                implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1354052_1_54639
            }

            /*D4执行循环增目标子周期预算占比标准数据(公共)[8024]   */
            Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getAccountId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-归属账户ID不能为空", false);
            Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getBelongToContentTypeCode(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-数据归属内容表类型编码不能为空", false);
            Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getBelongToContentId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-数据归属内容表主键ID不能为空", false);
            Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getEvaObjTargetCycleId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-内容目标父周期ID不能为空", false);
            Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getCycleId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-父周期ID不能为空", false);
            Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getEvaluationTemplateId(), "D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-冗余评价模板ID不能为空", false);
            implementLoopAddSubCycleBudgetPropStandardDataComRespDto = fwCalcStandardDataClient.implementLoopAddSubCycleBudgetPropStandardDataCom(implementLoopAddSubCycleBudgetPropStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        ImplementAddTargetCycleBudgetStandardDataComRespDto retData = new ImplementAddTargetCycleBudgetStandardDataComRespDto();


        return retData;
    }

    /**
     * D3执行循环增祖先预算标准数据(公共)[7731]
     * gen by moon at 1/31/2024, 8:45:17 PM
     */
    @Trace(operationName = "D3执行循环增祖先预算标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopAddAncestorBudgetStandardDataComRespDto implementLoopAddAncestorBudgetStandardDataCom(ImplementLoopAddAncestorBudgetStandardDataComReqDto reqDto) {


        QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto_1 = null;
        //virtualUsage D3查祖先目标周期列表(公共)  52101
        QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto = null;
        QueryAncestorTargetCycleListComReqDto queryAncestorTargetCycleListComReqDto = new QueryAncestorTargetCycleListComReqDto();
        queryAncestorTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1247796_1_52101
        queryAncestorTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1247797_1_52101
        if (reqDto != null) {
            queryAncestorTargetCycleListComReqDto.setComCode(reqDto.getCurrentContentCode());//SimpleFieldAssign//sourceId:1247795_1_52101
            queryAncestorTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247798_1_52101
        }

        /*D3查祖先目标周期列表(公共)[6312]   */
        Assert.isNull(queryAncestorTargetCycleListComReqDto.getComCode(), "D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-通用编码标识不能为空", false);
        Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjEntityId(), "D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjTypeCode(), "D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaluationTemplateId(), "D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-冗余评价模板ID不能为空", false);
        queryAncestorTargetCycleListComRespDto = targetContentService.queryAncestorTargetCycleListCom(queryAncestorTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


        queryAncestorTargetCycleListComRespDto_1 = queryAncestorTargetCycleListComRespDto;
        if (((new ArrayList<>()).size() > 0)) {
            //if(D3查祖先目标周期列表(公共).被评对象目标周期列表数据集条数 大于 0)  52100

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : queryAncestorTargetCycleListComRespDto.getEvaObjTargetCycleList()) {

                ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
                ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto = new ImplementContentTypeChangeTableTypeComReqDto();
                if (circulationCollectionsRes != null) {
                    implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1247860_1_52106
                }

                /*D3内容类型转表类型(公共)[5354]   */
                Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(), "D3执行循环增祖先预算标准数据(公共)-D3内容类型转表类型(公共)-关联目标内容类型编码不能为空", false);
                implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


                ImplementAddTargetCycleBudgetStandardDataComRespDto implementAddTargetCycleBudgetStandardDataComRespDto = null;
                if (implementContentTypeChangeTableTypeComRespDto != null) {
                    ImplementAddTargetCycleBudgetStandardDataComReqDto implementAddTargetCycleBudgetStandardDataComReqDto = new ImplementAddTargetCycleBudgetStandardDataComReqDto();
                    implementAddTargetCycleBudgetStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1247837_1_52104
                    implementAddTargetCycleBudgetStandardDataComReqDto.setCalcStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1247838_1_52104
                    if (reqDto != null) {
                        implementAddTargetCycleBudgetStandardDataComReqDto.setEvaObjTargetCycleList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:1247839_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247830_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1247831_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1247832_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setOpenMidCycle(reqDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1247834_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247833_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511518_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511519_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511520_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511521_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511522_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511523_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511524_1_52104
                    }
                    if (circulationCollectionsRes != null) {
                        implementAddTargetCycleBudgetStandardDataComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247836_1_52104
                        implementAddTargetCycleBudgetStandardDataComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247835_1_52104
                    }
                    if (implementContentTypeChangeTableTypeComRespDto != null) {
                        implementAddTargetCycleBudgetStandardDataComReqDto.setBelongToContentTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1247840_1_52104
                    }

                    /*D3执行增目标内容预算标准数据(公共)[7729]   */
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getEvaObjEntityId(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getTargetCycleContentId(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getEvaluationTemplateId(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getPeriodicModeTypeCode(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-周期模式类型编码不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getParentSubMidCycleType(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-父子中周期类型不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getOpenMidCycle(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-是否开启中期不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getBelongToContentTypeCode(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-数据归属内容表类型编码不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getUnit(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-冗余单位不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getResultType(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-结果产生类型 不能为空", false);
                    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getCalcStartTime(), "D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-计算开始时间不能为空", false);
                    implementAddTargetCycleBudgetStandardDataComRespDto = implementAddTargetCycleBudgetStandardDataCom(implementAddTargetCycleBudgetStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementLoopAddAncestorBudgetStandardDataComRespDto retData = new ImplementLoopAddAncestorBudgetStandardDataComRespDto();
        if (queryAncestorTargetCycleListComRespDto_1 != null) {
            retData.setLookAncestorNodeList(queryAncestorTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, LookAncestorNodeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1513848_1
        }


        return retData;
    }

    /**
     * D3-更新当前及祖先预算标准数据(公共)[7690]
     * gen by moon at 1/31/2024, 8:41:47 PM
     */
    @Trace(operationName = "D3-更新当前及祖先预算标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RefreshParentBudgetStandardDataComRespDto refreshParentBudgetStandardDataCom(RefreshParentBudgetStandardDataComReqDto reqDto) {


        //virtualUsage D3-执行当前内容预算标准数据(公共)  52022
        ImplementCurBudgetStandardDataComRespDto implementCurBudgetStandardDataComRespDto = null;
        ImplementCurBudgetStandardDataComReqDto implementCurBudgetStandardDataComReqDto = new ImplementCurBudgetStandardDataComReqDto();
        if (reqDto != null) {
            implementCurBudgetStandardDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1244785_1_52022
            implementCurBudgetStandardDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244786_1_52022
            implementCurBudgetStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1244779_1_52022
            implementCurBudgetStandardDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1244783_1_52022
            implementCurBudgetStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244780_1_52022
            implementCurBudgetStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1244781_1_52022
            implementCurBudgetStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244782_1_52022
            implementCurBudgetStandardDataComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1514983_1_52022
            implementCurBudgetStandardDataComReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514982_1_52022
        }

        /*D3-执行当前内容预算标准数据(公共)[7714]   */
        Assert.isNull(implementCurBudgetStandardDataComReqDto.getTargetCycleContentId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(implementCurBudgetStandardDataComReqDto.getTargetCycleContentTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(implementCurBudgetStandardDataComReqDto.getEvaObjTargetCycleId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(implementCurBudgetStandardDataComReqDto.getCycleId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-周期ID不能为空", false);
        Assert.isNull(implementCurBudgetStandardDataComReqDto.getUpdateCycleId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-更新周期ID不能为空", false);
        Assert.isNull(implementCurBudgetStandardDataComReqDto.getEvaluationTemplateId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-冗余评价模板ID不能为空", false);
        implementCurBudgetStandardDataComRespDto = implementCurBudgetStandardDataCom(implementCurBudgetStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage M3-执行财务账户【循环开始】  51998
        //ModelCode: circulationCollections
        for (FinanceAccountDto circulationCollectionsRes : reqDto.getFinanceAccountList()) {

//virtualUsage 3-3-09查被评对象目标周期详情  52025
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1244969_1_52025
            if (queryEvaObjTargetCycleDetailReq != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1244963_1_52025
                queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1244964_1_52025
                queryEvaObjTargetCycleDetailReq.setTreeTypeCode("PLAN_TREE");//sourceId:1244965_1_52025
            }
            if (circulationCollectionsRes != null) {
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1244967_1_52025
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244966_1_52025
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1245072_1_52025
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244968_1_52025
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTreeTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-树类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-11查周期阶段资料详情  52026
            OmsTspeCycleStageData omsTspeCycleStageData = null;
            if (omsEvaluationObjectTargetCycle != null) {
                QueryCycleStageDataDetailReq queryCycleStageDataDetailReq = new QueryCycleStageDataDetailReq();
                queryCycleStageDataDetailReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:1245080_1_52026
                queryCycleStageDataDetailReq.setStageContentType("STA_WOR_SUM_CON");//sourceId:1245078_1_52026
                queryCycleStageDataDetailReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1245079_1_52026
                if (reqDto != null) {
                    queryCycleStageDataDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1245077_1_52026
                    queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1245082_1_52026
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    queryCycleStageDataDetailReq.setCycleDataObjId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1245081_1_52026
                }

                /*3-3-11查周期阶段资料详情[2771]   */
                Assert.isNull(queryCycleStageDataDetailReq.getCycleId(), "D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期ID不能为空", false);
                Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjId(), "D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期资料归属对象ID不能为空", false);
                Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期资料归属对象类型编码不能为空", false);
                Assert.isNull(queryCycleStageDataDetailReq.getStageContentType(), "D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-内容性质类型编码不能为空", false);
                Assert.isNull(queryCycleStageDataDetailReq.getCycleDataTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期阶段资料类型编码不能为空", false);
                Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(), "D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空", false);
                omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//virtualUsage D3-执行当前内容预算标准数据(公共)  52023
            ImplementCurBudgetStandardDataComRespDto implementCurBudgetStandardDataComRespDto_1 = null;
            if (omsEvaluationObjectTargetCycle != null && omsTspeCycleStageData != null) {
                ImplementCurBudgetStandardDataComReqDto implementCurBudgetStandardDataComReqDto_1 = new ImplementCurBudgetStandardDataComReqDto();
                if (circulationCollectionsRes != null) {
                    implementCurBudgetStandardDataComReqDto_1.setTargetCycleContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1244785_1_52023
                    implementCurBudgetStandardDataComReqDto_1.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244786_1_52023
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    implementCurBudgetStandardDataComReqDto_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1244779_1_52023
                }
                if (omsTspeCycleStageData != null) {
                    implementCurBudgetStandardDataComReqDto_1.setCycleStageDataId(omsTspeCycleStageData.getCycleStageDataId());//SimpleFieldAssign//sourceId:1244783_1_52023
                }
                if (reqDto != null) {
                    implementCurBudgetStandardDataComReqDto_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244780_1_52023
                    implementCurBudgetStandardDataComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1244781_1_52023
                    implementCurBudgetStandardDataComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244782_1_52023
                    implementCurBudgetStandardDataComReqDto_1.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1514983_1_52023
                    implementCurBudgetStandardDataComReqDto_1.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514982_1_52023
                }

                /*D3-执行当前内容预算标准数据(公共)[7714]   */
                Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getTargetCycleContentId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getTargetCycleContentTypeCode(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getEvaObjTargetCycleId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getCycleId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-周期ID不能为空", false);
                Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getUpdateCycleId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getEvaluationTemplateId(), "D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-冗余评价模板ID不能为空", false);
                implementCurBudgetStandardDataComRespDto_1 = implementCurBudgetStandardDataCom(implementCurBudgetStandardDataComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
//virtualUsage M3-执行【循环结束】  52000
            //ModelCode: circulationEnd
        }

        RefreshParentBudgetStandardDataComRespDto retData = new RefreshParentBudgetStandardDataComRespDto();


        return retData;
    }

    /**
     * D3-执行当前内容预算标准数据(公共)[7714]
     * gen by moon at 2/1/2024, 1:13:16 AM
     */
    @Trace(operationName = "D3-执行当前内容预算标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCurBudgetStandardDataComRespDto implementCurBudgetStandardDataCom(ImplementCurBudgetStandardDataComReqDto reqDto) {


        //virtualUsage 约定：数据类型编码  52024
        //ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
        ImplementAcceptFieldByStandardDataReqDto receptionServiceReq = new ImplementAcceptFieldByStandardDataReqDto();
        receptionServiceReq.setBudgetTotalType("BUDGET_TOTAL");//CUSTOM_CONVENTION//sourceId:1244811_1_52024
        receptionServiceReq.setBudgetAmountType("BUDGET_AMOUNT");//CUSTOM_CONVENTION//sourceId:1244807_1_52024
        receptionServiceReq.setBudgetUsableType("BUDGET_USABLE");//CUSTOM_CONVENTION//sourceId:1244808_1_52024
        receptionServiceReq.setBudgetFrozenType("BUDGET_FROZEN");//CUSTOM_CONVENTION//sourceId:1244809_1_52024
        receptionServiceReq.setCumulativeBudgetType("CUMULATIVE_BUDGET");//CUSTOM_CONVENTION//sourceId:1244810_1_52024
        receptionServiceReq.setFundsReceivedTotalType("FUNDS_RECEIVED_TOTAL");//CUSTOM_CONVENTION//sourceId:1244816_1_52024
        receptionServiceReq.setFundsReceivedBalanceType("FUNDS_RECEIVED_BALANCE");//CUSTOM_CONVENTION//sourceId:1244812_1_52024
        receptionServiceReq.setFundsReceivedUsableType("FUNDS_RECEIVED_USABLE");//CUSTOM_CONVENTION//sourceId:1244814_1_52024
        receptionServiceReq.setFundsReceivedFrozenType("FUNDS_RECEIVED_FROZEN");//CUSTOM_CONVENTION//sourceId:1244815_1_52024
        receptionServiceReq.setCumulativeFundsReceivedType("CUMULATIVE_FUNDS_RECEIVED");//CUSTOM_CONVENTION//sourceId:1244813_1_52024

        /*约定：数据类型编码[7478]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getBudgetTotalType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算账户累计总金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getBudgetAmountType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算账户余额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getBudgetUsableType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算可用金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getBudgetFrozenType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算冻结金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getCumulativeBudgetType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-累计结算金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getFundsReceivedTotalType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户累计到账总金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getFundsReceivedBalanceType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户余额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getFundsReceivedUsableType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户可用金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getFundsReceivedFrozenType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户冻结金额类型不能为空", false);
        Assert.isNull(receptionServiceReq.getCumulativeFundsReceivedType(), "D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-累计使用金额类型不能为空", false);
        receptionServiceRes = nbStandardData.implementAcceptFieldByStandardData(receptionServiceReq);


//virtualUsage D4-1查标准数据详情(公共)  52019
        QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
        QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
        queryStandardDataDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1244594_1_52019
        queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1244595_1_52019
        if (reqDto != null) {
            queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1244593_1_52019
            queryStandardDataDetailComReqDto.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244592_1_52019
            queryStandardDataDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1244610_1_52019
            queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244596_1_52019
        }

        /*D4-1查标准数据详情(公共)[2695]   */
        Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
        Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
        Assert.isNull(queryStandardDataDetailComReqDto.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-更新周期ID不能为空", false);
        Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-数据使用场景编码不能为空", false);
        Assert.isNull(queryStandardDataDetailComReqDto.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-数据类型编码不能为空", false);
        Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
        Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
        queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D7-查预算账户详情(公共)  52001
        QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
        QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto = new QueryFinanceAccountDetailComReqDto();
        queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1244081_1_52001
        queryFinanceAccountDetailComReqDto.setIsArchive("FALSE");//sourceId:1244083_1_52001
        queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1244084_1_52001
        if (reqDto != null) {
            queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1244082_1_52001
        }

        /*D7-查预算账户详情(公共)[7681]   */
        Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(), "D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-关联归属主体ID不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(), "D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-是否预算账户不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto.getIsArchive(), "D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-是否存档不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(), "D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-创建于空间ID不能为空", false);
        queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3-执行提交标准数据准备(公共)  60393
        ImplementReadyForCommitStandardDataComRespDto implementReadyForCommitStandardDataComRespDto = null;
        if (queryStandardDataDetailComRespDto != null) {
            ImplementReadyForCommitStandardDataComReqDto implementReadyForCommitStandardDataComReqDto = new ImplementReadyForCommitStandardDataComReqDto();
            if (reqDto != null) {
                implementReadyForCommitStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513245_1_60393
                implementReadyForCommitStandardDataComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1513257_1_60393
                implementReadyForCommitStandardDataComReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514453_1_60393
                implementReadyForCommitStandardDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1513247_1_60393
                implementReadyForCommitStandardDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513248_1_60393
                implementReadyForCommitStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513244_1_60393
            }
            if (queryStandardDataDetailComRespDto != null) {
                implementReadyForCommitStandardDataComReqDto.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513246_1_60393
            }

            /*D3-执行提交标准数据准备(公共)[7023]   */
            Assert.isNull(implementReadyForCommitStandardDataComReqDto.getEvaObjTargetCycleId(), "D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(implementReadyForCommitStandardDataComReqDto.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-周期ID不能为空", false);
            Assert.isNull(implementReadyForCommitStandardDataComReqDto.getTargetCycleContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(implementReadyForCommitStandardDataComReqDto.getTargetCycleContentId(), "D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementReadyForCommitStandardDataComReqDto.getEvaluationTemplateId(), "D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-冗余评价模板ID不能为空", false);
            implementReadyForCommitStandardDataComRespDto = implementReadyForCommitStandardDataCom(implementReadyForCommitStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;


        }
        if ((queryFinanceAccountDetailComRespDto != null && queryFinanceAccountDetailComRespDto.getAccountId() != null)) {
            //if(D7-查预算账户详情(公共).账户ID 值不等于空 )  60340

            CommitStandardDataComRespDto commitStandardDataComRespDto = null;
            if (queryFinanceAccountDetailComRespDto != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60403
                commitStandardDataComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60403
                commitStandardDataComReqDto.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60403
                commitStandardDataComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60403
                commitStandardDataComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60403
                commitStandardDataComReqDto.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60403
                commitStandardDataComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60403
                commitStandardDataComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60403
                if (queryFinanceAccountDetailComRespDto != null) {
                    commitStandardDataComReqDto.setDataResult(queryFinanceAccountDetailComRespDto.getAccountActualBalance());//SimpleFieldAssign//sourceId:1513813_1_60403
                    commitStandardDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60403
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60403
                    commitStandardDataComReqDto.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60403
                    commitStandardDataComReqDto.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60403
                    commitStandardDataComReqDto.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60403
                    commitStandardDataComReqDto.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60403
                    commitStandardDataComReqDto.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60403
                    commitStandardDataComReqDto.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1515218_1_60403
                    commitStandardDataComReqDto.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1515219_1_60403
                    commitStandardDataComReqDto.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60403
                    commitStandardDataComReqDto.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60403
                    commitStandardDataComReqDto.setPersonLiableObjId(queryStandardDataDetailComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1513825_1_60403
                    commitStandardDataComReqDto.setBizRoleObjId(queryStandardDataDetailComRespDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1513827_1_60403
                    commitStandardDataComReqDto.setBizRoleObjCode(queryStandardDataDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1513829_1_60403
                    commitStandardDataComReqDto.setBizRoleObjName(queryStandardDataDetailComRespDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1513828_1_60403
                    commitStandardDataComReqDto.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60403
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60403
//commitStandardDataComReqDto.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60403
                    commitStandardDataComReqDto.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60403
//commitStandardDataComReqDto.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60403
                    commitStandardDataComReqDto.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60403
                    commitStandardDataComReqDto.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60403
                    commitStandardDataComReqDto.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60403
                    commitStandardDataComReqDto.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60403
                    commitStandardDataComReqDto.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60403
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto.setDataType(receptionServiceRes.getBudgetAmountType());//SimpleFieldAssign//sourceId:1513815_1_60403
                }
                if (reqDto != null) {
//      commitStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60403
//commitStandardDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60403
                    commitStandardDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60403
                    commitStandardDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60403
                }

                /*D4-1提交标准数据(用于预算账户)[5640]   */
                Assert.isNull(commitStandardDataComReqDto.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空", false);
                commitStandardDataComRespDto = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_1 = null;
            if (queryFinanceAccountDetailComRespDto != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_1 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60406
                commitStandardDataComReqDto_1.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60406
                commitStandardDataComReqDto_1.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60406
                commitStandardDataComReqDto_1.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60406
                commitStandardDataComReqDto_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60406
                commitStandardDataComReqDto_1.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60406
                commitStandardDataComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60406
                commitStandardDataComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60406
                if (queryFinanceAccountDetailComRespDto != null) {
                    commitStandardDataComReqDto_1.setDataResult(queryFinanceAccountDetailComRespDto.getSettlableBalance());//SimpleFieldAssign//sourceId:1513813_1_60406
                    commitStandardDataComReqDto_1.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60406
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_1.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60406
                    commitStandardDataComReqDto_1.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60406
                    commitStandardDataComReqDto_1.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60406
                    commitStandardDataComReqDto_1.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60406
                    commitStandardDataComReqDto_1.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60406
                    commitStandardDataComReqDto_1.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60406
                    commitStandardDataComReqDto_1.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60406
                    commitStandardDataComReqDto_1.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60406
                    commitStandardDataComReqDto_1.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60406
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_1.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60406
//commitStandardDataComReqDto_1.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60406
                    commitStandardDataComReqDto_1.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60406
//commitStandardDataComReqDto_1.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60406
                    commitStandardDataComReqDto_1.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60406
                    commitStandardDataComReqDto_1.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60406
                    commitStandardDataComReqDto_1.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60406
                    commitStandardDataComReqDto_1.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1513827_1_60406
                    commitStandardDataComReqDto_1.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1513829_1_60406
                    commitStandardDataComReqDto_1.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1513828_1_60406
                    commitStandardDataComReqDto_1.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60406
                    commitStandardDataComReqDto_1.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60406
                    commitStandardDataComReqDto_1.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60406
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_1.setDataType(receptionServiceRes.getBudgetUsableType());//SimpleFieldAssign//sourceId:1513815_1_60406
                }
                if (reqDto != null) {
//      commitStandardDataComReqDto_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60406
//commitStandardDataComReqDto_1.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60406
                    commitStandardDataComReqDto_1.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60406
                    commitStandardDataComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60406
                }

                /*D4-1提交标准数据(用于预算账户)[5640]   */
                Assert.isNull(commitStandardDataComReqDto_1.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto_1.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_1.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_1.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空", false);
                commitStandardDataComRespDto_1 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_2 = null;
            if (queryFinanceAccountDetailComRespDto != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_2 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_2.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60413
                commitStandardDataComReqDto_2.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60413
                commitStandardDataComReqDto_2.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60413
                commitStandardDataComReqDto_2.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60413
                commitStandardDataComReqDto_2.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60413
                commitStandardDataComReqDto_2.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60413
                commitStandardDataComReqDto_2.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60413
                commitStandardDataComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60413
                if (queryFinanceAccountDetailComRespDto != null) {
                    commitStandardDataComReqDto_2.setDataResult(queryFinanceAccountDetailComRespDto.getUnSettlableBalance());//SimpleFieldAssign//sourceId:1513813_1_60413
                    commitStandardDataComReqDto_2.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60413
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_2.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60413
                    commitStandardDataComReqDto_2.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60413
                    commitStandardDataComReqDto_2.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60413
                    commitStandardDataComReqDto_2.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60413
                    commitStandardDataComReqDto_2.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60413
                    commitStandardDataComReqDto_2.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60413
                    commitStandardDataComReqDto_2.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60413
                    commitStandardDataComReqDto_2.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60413
                    commitStandardDataComReqDto_2.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60413
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_2.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60413
//commitStandardDataComReqDto_2.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60413
                    commitStandardDataComReqDto_2.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60413
//commitStandardDataComReqDto_2.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60413
                    commitStandardDataComReqDto_2.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60413
                    commitStandardDataComReqDto_2.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60413
                    commitStandardDataComReqDto_2.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60413
                    commitStandardDataComReqDto_2.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1513827_1_60413
                    commitStandardDataComReqDto_2.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1513829_1_60413
                    commitStandardDataComReqDto_2.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1513828_1_60413
                    commitStandardDataComReqDto_2.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60413
                    commitStandardDataComReqDto_2.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60413
                    commitStandardDataComReqDto_2.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60413
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_2.setDataType(receptionServiceRes.getBudgetFrozenType());//SimpleFieldAssign//sourceId:1513815_1_60413
                }
                if (reqDto != null) {
//      commitStandardDataComReqDto_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60413
//commitStandardDataComReqDto_2.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60413
                    commitStandardDataComReqDto_2.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60413
                    commitStandardDataComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60413
                }

                /*D4-1提交标准数据(用于预算账户)[5640]   */
                Assert.isNull(commitStandardDataComReqDto_2.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto_2.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_2.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_2.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空", false);
                commitStandardDataComRespDto_2 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_3 = null;
            if (queryFinanceAccountDetailComRespDto != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_3 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_3.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60414
                commitStandardDataComReqDto_3.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60414
                commitStandardDataComReqDto_3.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60414
                commitStandardDataComReqDto_3.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60414
                commitStandardDataComReqDto_3.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60414
                commitStandardDataComReqDto_3.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60414
                commitStandardDataComReqDto_3.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60414
                commitStandardDataComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60414
                if (queryFinanceAccountDetailComRespDto != null) {
                    commitStandardDataComReqDto_3.setDataResult(queryFinanceAccountDetailComRespDto.getAccruedSettledAmount());//SimpleFieldAssign//sourceId:1513813_1_60414
                    commitStandardDataComReqDto_3.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60414
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_3.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60414
                    commitStandardDataComReqDto_3.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60414
                    commitStandardDataComReqDto_3.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60414
                    commitStandardDataComReqDto_3.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60414
                    commitStandardDataComReqDto_3.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60414
                    commitStandardDataComReqDto_3.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60414
                    commitStandardDataComReqDto_3.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60414
                    commitStandardDataComReqDto_3.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60414
                    commitStandardDataComReqDto_3.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60414
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_3.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60414
//commitStandardDataComReqDto_3.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60414
                    commitStandardDataComReqDto_3.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60414
//commitStandardDataComReqDto_3.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60414
                    commitStandardDataComReqDto_3.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60414
                    commitStandardDataComReqDto_3.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60414
                    commitStandardDataComReqDto_3.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60414
                    commitStandardDataComReqDto_3.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1513827_1_60414
                    commitStandardDataComReqDto_3.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1513829_1_60414
                    commitStandardDataComReqDto_3.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1513828_1_60414
                    commitStandardDataComReqDto_3.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60414
                    commitStandardDataComReqDto_3.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60414
                    commitStandardDataComReqDto_3.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60414
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_3.setDataType(receptionServiceRes.getCumulativeBudgetType());//SimpleFieldAssign//sourceId:1513815_1_60414
                }
                if (reqDto != null) {
//      commitStandardDataComReqDto_3.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60414
//commitStandardDataComReqDto_3.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60414
                    commitStandardDataComReqDto_3.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60414
                    commitStandardDataComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60414
                }

                /*D4-1提交标准数据(用于预算账户)[5640]   */
                Assert.isNull(commitStandardDataComReqDto_3.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto_3.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_3.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_3.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空", false);
                commitStandardDataComRespDto_3 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_4 = null;
            if (queryFinanceAccountDetailComRespDto != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_4 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_4.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60415
                commitStandardDataComReqDto_4.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60415
                commitStandardDataComReqDto_4.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60415
                commitStandardDataComReqDto_4.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60415
                commitStandardDataComReqDto_4.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60415
                commitStandardDataComReqDto_4.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60415
                commitStandardDataComReqDto_4.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60415
                commitStandardDataComReqDto_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60415
                if (queryFinanceAccountDetailComRespDto != null) {
                    commitStandardDataComReqDto_4.setDataResult(queryFinanceAccountDetailComRespDto.getTotalBudgetAmount());//SimpleFieldAssign//sourceId:1513813_1_60415
                    commitStandardDataComReqDto_4.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60415
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_4.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60415
                    commitStandardDataComReqDto_4.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60415
                    commitStandardDataComReqDto_4.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60415
                    commitStandardDataComReqDto_4.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60415
                    commitStandardDataComReqDto_4.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60415
                    commitStandardDataComReqDto_4.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60415
                    commitStandardDataComReqDto_4.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60415
                    commitStandardDataComReqDto_4.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60415
                    commitStandardDataComReqDto_4.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60415
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_4.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60415
//commitStandardDataComReqDto_4.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60415
                    commitStandardDataComReqDto_4.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60415
//commitStandardDataComReqDto_4.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60415
                    commitStandardDataComReqDto_4.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60415
                    commitStandardDataComReqDto_4.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60415
                    commitStandardDataComReqDto_4.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60415
                    commitStandardDataComReqDto_4.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1513827_1_60415
                    commitStandardDataComReqDto_4.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1513829_1_60415
                    commitStandardDataComReqDto_4.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1513828_1_60415
                    commitStandardDataComReqDto_4.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60415
                    commitStandardDataComReqDto_4.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60415
                    commitStandardDataComReqDto_4.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60415
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_4.setDataType(receptionServiceRes.getBudgetTotalType());//SimpleFieldAssign//sourceId:1513815_1_60415
                }
                if (reqDto != null) {
//      commitStandardDataComReqDto_4.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60415
//commitStandardDataComReqDto_4.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60415
                    commitStandardDataComReqDto_4.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60415
                    commitStandardDataComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60415
                }

                /*D4-1提交标准数据(用于预算账户)[5640]   */
                Assert.isNull(commitStandardDataComReqDto_4.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto_4.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_4.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_4.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空", false);
                commitStandardDataComRespDto_4 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
//virtualUsage D7-查实体账户详情(公共)  52007
        QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_2 = null;
        QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto_1 = new QueryFinanceAccountDetailComReqDto();
        queryFinanceAccountDetailComReqDto_1.setIsBudgetAccount("FALSE");//sourceId:1244114_1_52007
        queryFinanceAccountDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1244116_1_52007
        queryFinanceAccountDetailComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1244117_1_52007
        if (reqDto != null) {
            queryFinanceAccountDetailComReqDto_1.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1244115_1_52007
        }

        /*D7-查实体账户详情(公共)[7681]   */
        Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountObjectId(), "D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-关联归属主体ID不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsBudgetAccount(), "D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-是否预算账户不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsArchive(), "D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-是否存档不能为空", false);
        Assert.isNull(queryFinanceAccountDetailComReqDto_1.getSpaceId(), "D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-创建于空间ID不能为空", false);
        queryFinanceAccountDetailComRespDto_2 = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryFinanceAccountDetailComRespDto_2 != null && queryFinanceAccountDetailComRespDto_2.getAccountId() != null)) {
            //if(D7-查实体账户详情(公共).账户ID 值不等于空 )  60352

            CommitStandardDataComRespDto commitStandardDataComRespDto_5 = null;
            if (queryFinanceAccountDetailComRespDto_2 != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_5 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_5.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60419
                commitStandardDataComReqDto_5.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60419
                commitStandardDataComReqDto_5.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60419
                commitStandardDataComReqDto_5.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60419
                commitStandardDataComReqDto_5.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60419
                commitStandardDataComReqDto_5.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60419
                commitStandardDataComReqDto_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60419
                commitStandardDataComReqDto_5.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60419
                if (reqDto != null) {
//      commitStandardDataComReqDto_5.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60419
//commitStandardDataComReqDto_5.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60419
                    commitStandardDataComReqDto_5.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60419
                    commitStandardDataComReqDto_5.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60419
                }
                if (queryFinanceAccountDetailComRespDto_2 != null) {
                    commitStandardDataComReqDto_5.setDataResult(queryFinanceAccountDetailComRespDto_2.getAccountActualBalance());//SimpleFieldAssign//sourceId:1514101_1_60419
                    commitStandardDataComReqDto_5.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60419
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_5.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60419
                    commitStandardDataComReqDto_5.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60419
                    commitStandardDataComReqDto_5.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60419
                    commitStandardDataComReqDto_5.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60419
                    commitStandardDataComReqDto_5.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60419
                    commitStandardDataComReqDto_5.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60419
                    commitStandardDataComReqDto_5.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60419
                    commitStandardDataComReqDto_5.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60419
                    commitStandardDataComReqDto_5.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60419
                    commitStandardDataComReqDto_5.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60419
                    commitStandardDataComReqDto_5.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60419
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_5.setDataType(receptionServiceRes.getFundsReceivedBalanceType());//SimpleFieldAssign//sourceId:1514103_1_60419
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_5.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60419
//commitStandardDataComReqDto_5.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60419
                    commitStandardDataComReqDto_5.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60419
//commitStandardDataComReqDto_5.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60419
                    commitStandardDataComReqDto_5.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60419
                    commitStandardDataComReqDto_5.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60419
                    commitStandardDataComReqDto_5.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60419
                    commitStandardDataComReqDto_5.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1514115_1_60419
                    commitStandardDataComReqDto_5.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1514117_1_60419
                    commitStandardDataComReqDto_5.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1514116_1_60419
                    commitStandardDataComReqDto_5.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60419
                    commitStandardDataComReqDto_5.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60419
                    commitStandardDataComReqDto_5.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60419
                }

                /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_5.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_5.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getUnit(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getDataUsageSceneCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getWorkCycleUpdateSlice(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getParentSubMidCycleType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getIsWorkCycleData(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBelongToPersonalIdentityId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_5.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空", false);
                commitStandardDataComRespDto_5 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_6 = null;
            if (queryFinanceAccountDetailComRespDto_2 != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_6 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_6.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60420
                commitStandardDataComReqDto_6.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60420
                commitStandardDataComReqDto_6.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60420
                commitStandardDataComReqDto_6.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60420
                commitStandardDataComReqDto_6.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60420
                commitStandardDataComReqDto_6.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60420
                commitStandardDataComReqDto_6.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60420
                commitStandardDataComReqDto_6.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60420
                if (reqDto != null) {
//      commitStandardDataComReqDto_6.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60420
//commitStandardDataComReqDto_6.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60420
                    commitStandardDataComReqDto_6.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60420
                    commitStandardDataComReqDto_6.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60420
                }
                if (queryFinanceAccountDetailComRespDto_2 != null) {
                    commitStandardDataComReqDto_6.setDataResult(queryFinanceAccountDetailComRespDto_2.getSettlableBalance());//SimpleFieldAssign//sourceId:1514101_1_60420
                    commitStandardDataComReqDto_6.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60420
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_6.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60420
                    commitStandardDataComReqDto_6.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60420
                    commitStandardDataComReqDto_6.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60420
                    commitStandardDataComReqDto_6.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60420
                    commitStandardDataComReqDto_6.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60420
                    commitStandardDataComReqDto_6.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60420
                    commitStandardDataComReqDto_6.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60420
                    commitStandardDataComReqDto_6.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60420
                    commitStandardDataComReqDto_6.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60420
                    commitStandardDataComReqDto_6.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60420
                    commitStandardDataComReqDto_6.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60420
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_6.setDataType(receptionServiceRes.getFundsReceivedUsableType());//SimpleFieldAssign//sourceId:1514103_1_60420
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_6.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60420
//commitStandardDataComReqDto_6.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60420
                    commitStandardDataComReqDto_6.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60420
//commitStandardDataComReqDto_6.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60420
                    commitStandardDataComReqDto_6.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60420
                    commitStandardDataComReqDto_6.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60420
                    commitStandardDataComReqDto_6.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60420
                    commitStandardDataComReqDto_6.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1514115_1_60420
                    commitStandardDataComReqDto_6.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1514117_1_60420
                    commitStandardDataComReqDto_6.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1514116_1_60420
                    commitStandardDataComReqDto_6.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60420
                    commitStandardDataComReqDto_6.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60420
                    commitStandardDataComReqDto_6.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60420
                }

                /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_6.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_6.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getUnit(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getDataUsageSceneCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getWorkCycleUpdateSlice(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getParentSubMidCycleType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getIsWorkCycleData(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBelongToPersonalIdentityId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_6.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空", false);
                commitStandardDataComRespDto_6 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_6).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_7 = null;
            if (queryFinanceAccountDetailComRespDto_2 != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_7 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_7.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60421
                commitStandardDataComReqDto_7.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60421
                commitStandardDataComReqDto_7.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60421
                commitStandardDataComReqDto_7.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60421
                commitStandardDataComReqDto_7.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60421
                commitStandardDataComReqDto_7.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60421
                commitStandardDataComReqDto_7.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60421
                commitStandardDataComReqDto_7.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60421
                if (reqDto != null) {
//      commitStandardDataComReqDto_7.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60421
//commitStandardDataComReqDto_7.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60421
                    commitStandardDataComReqDto_7.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60421
                    commitStandardDataComReqDto_7.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60421
                }
                if (queryFinanceAccountDetailComRespDto_2 != null) {
                    commitStandardDataComReqDto_7.setDataResult(queryFinanceAccountDetailComRespDto_2.getUnSettlableBalance());//SimpleFieldAssign//sourceId:1514101_1_60421
                    commitStandardDataComReqDto_7.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60421
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_7.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60421
                    commitStandardDataComReqDto_7.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60421
                    commitStandardDataComReqDto_7.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60421
                    commitStandardDataComReqDto_7.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60421
                    commitStandardDataComReqDto_7.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60421
                    commitStandardDataComReqDto_7.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60421
                    commitStandardDataComReqDto_7.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60421
                    commitStandardDataComReqDto_7.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60421
                    commitStandardDataComReqDto_7.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60421
                    commitStandardDataComReqDto_7.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60421
                    commitStandardDataComReqDto_7.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60421
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_7.setDataType(receptionServiceRes.getFundsReceivedFrozenType());//SimpleFieldAssign//sourceId:1514103_1_60421
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_7.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60421
//commitStandardDataComReqDto_7.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60421
                    commitStandardDataComReqDto_7.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60421
//commitStandardDataComReqDto_7.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60421
                    commitStandardDataComReqDto_7.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60421
                    commitStandardDataComReqDto_7.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60421
                    commitStandardDataComReqDto_7.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60421
                    commitStandardDataComReqDto_7.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1514115_1_60421
                    commitStandardDataComReqDto_7.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1514117_1_60421
                    commitStandardDataComReqDto_7.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1514116_1_60421
                    commitStandardDataComReqDto_7.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60421
                    commitStandardDataComReqDto_7.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60421
                    commitStandardDataComReqDto_7.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60421
                }

                /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_7.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_7.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getUnit(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getDataUsageSceneCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getWorkCycleUpdateSlice(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getParentSubMidCycleType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getIsWorkCycleData(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBelongToPersonalIdentityId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_7.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空", false);
                commitStandardDataComRespDto_7 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_7).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_8 = null;
            if (queryFinanceAccountDetailComRespDto_2 != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_8 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_8.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60422
                commitStandardDataComReqDto_8.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60422
                commitStandardDataComReqDto_8.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60422
                commitStandardDataComReqDto_8.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60422
                commitStandardDataComReqDto_8.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60422
                commitStandardDataComReqDto_8.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60422
                commitStandardDataComReqDto_8.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60422
                commitStandardDataComReqDto_8.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60422
                if (reqDto != null) {
//      commitStandardDataComReqDto_8.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60422
//commitStandardDataComReqDto_8.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60422
                    commitStandardDataComReqDto_8.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60422
                    commitStandardDataComReqDto_8.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60422
                }
                if (queryFinanceAccountDetailComRespDto_2 != null) {
                    commitStandardDataComReqDto_8.setDataResult(queryFinanceAccountDetailComRespDto_2.getAccruedSettledAmount());//SimpleFieldAssign//sourceId:1514101_1_60422
                    commitStandardDataComReqDto_8.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60422
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_8.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60422
                    commitStandardDataComReqDto_8.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60422
                    commitStandardDataComReqDto_8.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60422
                    commitStandardDataComReqDto_8.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60422
                    commitStandardDataComReqDto_8.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60422
                    commitStandardDataComReqDto_8.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60422
                    commitStandardDataComReqDto_8.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60422
                    commitStandardDataComReqDto_8.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60422
                    commitStandardDataComReqDto_8.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60422
                    commitStandardDataComReqDto_8.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60422
                    commitStandardDataComReqDto_8.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60422
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_8.setDataType(receptionServiceRes.getCumulativeFundsReceivedType());//SimpleFieldAssign//sourceId:1514103_1_60422
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_8.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60422
//commitStandardDataComReqDto_8.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60422
                    commitStandardDataComReqDto_8.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60422
//commitStandardDataComReqDto_8.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60422
                    commitStandardDataComReqDto_8.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60422
                    commitStandardDataComReqDto_8.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60422
                    commitStandardDataComReqDto_8.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60422
                    commitStandardDataComReqDto_8.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1514115_1_60422
                    commitStandardDataComReqDto_8.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1514117_1_60422
                    commitStandardDataComReqDto_8.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1514116_1_60422
                    commitStandardDataComReqDto_8.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60422
                    commitStandardDataComReqDto_8.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60422
                    commitStandardDataComReqDto_8.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60422
                }

                /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_8.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_8.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getUnit(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getDataUsageSceneCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getWorkCycleUpdateSlice(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getParentSubMidCycleType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getIsWorkCycleData(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBelongToPersonalIdentityId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_8.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空", false);
                commitStandardDataComRespDto_8 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_8).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            CommitStandardDataComRespDto commitStandardDataComRespDto_9 = null;
            if (queryFinanceAccountDetailComRespDto_2 != null && queryStandardDataDetailComRespDto != null && implementReadyForCommitStandardDataComRespDto != null) {
                CommitStandardDataComReqDto commitStandardDataComReqDto_9 = new CommitStandardDataComReqDto();
                commitStandardDataComReqDto_9.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60423
                commitStandardDataComReqDto_9.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60423
                commitStandardDataComReqDto_9.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60423
                commitStandardDataComReqDto_9.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60423
                commitStandardDataComReqDto_9.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60423
                commitStandardDataComReqDto_9.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60423
                commitStandardDataComReqDto_9.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60423
                commitStandardDataComReqDto_9.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60423
                if (reqDto != null) {
//      commitStandardDataComReqDto_9.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60423
//commitStandardDataComReqDto_9.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60423
                    commitStandardDataComReqDto_9.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60423
                    commitStandardDataComReqDto_9.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60423
                }
                if (queryFinanceAccountDetailComRespDto_2 != null) {
                    commitStandardDataComReqDto_9.setDataResult(queryFinanceAccountDetailComRespDto_2.getTotalBudgetAmount());//SimpleFieldAssign//sourceId:1514101_1_60423
                    commitStandardDataComReqDto_9.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60423
                }
                if (queryStandardDataDetailComRespDto != null) {
                    commitStandardDataComReqDto_9.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60423
                    commitStandardDataComReqDto_9.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60423
                    commitStandardDataComReqDto_9.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60423
                    commitStandardDataComReqDto_9.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60423
                    commitStandardDataComReqDto_9.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60423
                    commitStandardDataComReqDto_9.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60423
                    commitStandardDataComReqDto_9.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60423
                    commitStandardDataComReqDto_9.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60423
                    commitStandardDataComReqDto_9.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60423
                    commitStandardDataComReqDto_9.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60423
                    commitStandardDataComReqDto_9.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60423
                }
                if (receptionServiceRes != null) {
                    commitStandardDataComReqDto_9.setDataType(receptionServiceRes.getFundsReceivedTotalType());//SimpleFieldAssign//sourceId:1514103_1_60423
                }
                if (implementReadyForCommitStandardDataComRespDto != null) {
//      commitStandardDataComReqDto_9.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60423
//commitStandardDataComReqDto_9.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60423
                    commitStandardDataComReqDto_9.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60423
//commitStandardDataComReqDto_9.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60423
                    commitStandardDataComReqDto_9.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60423
                    commitStandardDataComReqDto_9.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60423
                    commitStandardDataComReqDto_9.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60423
                    commitStandardDataComReqDto_9.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()) : "");//SimpleFieldAssign//sourceId:1514115_1_60423
                    commitStandardDataComReqDto_9.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()) : "");//SimpleFieldAssign//sourceId:1514117_1_60423
                    commitStandardDataComReqDto_9.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName() != null ? String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()) : "");//SimpleFieldAssign//sourceId:1514116_1_60423
                    commitStandardDataComReqDto_9.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60423
                    commitStandardDataComReqDto_9.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60423
                    commitStandardDataComReqDto_9.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60423
                }

                /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_9.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
                Assert.isNull(commitStandardDataComReqDto_9.getTableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getDataResult(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getUnit(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getDataType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getResultType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getDataUsageSceneCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleStartTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleEndTime(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getWorkCycleUpdateSlice(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getParentSubMidCycleType(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getIsWorkCycleData(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getPersonLiableObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getPersonLiableTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBizRoleObjId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBizRoleObjCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBizRoleObjName(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBelongToPersonalIdentityTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBelongToPersonalIdentityId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBelongToContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getBelongToContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getSubjectLifeCycle(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getThemeContentTypeCode(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空", false);
                Assert.isNull(commitStandardDataComReqDto_9.getThemeContentId(), "D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空", false);
                commitStandardDataComRespDto_9 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_9).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        ImplementCurBudgetStandardDataComRespDto retData = new ImplementCurBudgetStandardDataComRespDto();


        return retData;
    }

    /**
     * D3-执行自动汇报标准数据准备(公共)[8304]
     * gen by moon at 1/18/2024, 4:40:53 PM
     */
    @Trace(operationName = "D3-执行自动汇报标准数据准备(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAutoReportStandardDataComRespDto implementAutoReportStandardDataCom(ImplementAutoReportStandardDataComReqDto reqDto) {


        JudgeAutoReportVerifyProgressAndActualValueComRespDto judgeAutoReportVerifyProgressAndActualValueComRespDto_1 = null;
//virtualUsage 约定：进度值/实际值数据类型编码  59754
        //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
        ImplementFourthReceivingFieldReqDto receptionServiceReq = new ImplementFourthReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("PROGRESS_VALUE");//CUSTOM_CONVENTION//sourceId:1489624_1_59754
        receptionServiceReq.setCustomField2("ACTUAL_VALUE");//CUSTOM_CONVENTION//sourceId:1489625_1_59754

        /*约定：进度值/实际值数据类型编码[8259]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3-执行自动汇报标准数据准备(公共)-约定：进度值/实际值数据类型编码-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3-执行自动汇报标准数据准备(公共)-约定：进度值/实际值数据类型编码-自定义字段2不能为空", false);
        receptionServiceRes = nbStandardData.implementFourthReceivingField(receptionServiceReq);


//virtualUsage D3-判断自动汇报校验进度值与实际值(公共)  59601
        JudgeAutoReportVerifyProgressAndActualValueComRespDto judgeAutoReportVerifyProgressAndActualValueComRespDto = null;
        JudgeAutoReportVerifyProgressAndActualValueComReqDto judgeAutoReportVerifyProgressAndActualValueComReqDto = new JudgeAutoReportVerifyProgressAndActualValueComReqDto();
        if (reqDto != null) {
            judgeAutoReportVerifyProgressAndActualValueComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1486512_1_59601
            judgeAutoReportVerifyProgressAndActualValueComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1486513_1_59601
            judgeAutoReportVerifyProgressAndActualValueComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1486514_1_59601
            judgeAutoReportVerifyProgressAndActualValueComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1486515_1_59601
            judgeAutoReportVerifyProgressAndActualValueComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1486516_1_59601
            judgeAutoReportVerifyProgressAndActualValueComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1486517_1_59601
        }

        /*D3-判断自动汇报校验进度值与实际值(公共)[8299]   */
        Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getEvaObjTargetCycleId(), "D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getCycleId(), "D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-周期ID不能为空", false);
        Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getTargetCycleContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getTargetCycleContentId(), "D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getTargetId(), "D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-冗余目标ID不能为空", false);
        Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getEvaluationTemplateId(), "D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-冗余评价模板ID不能为空", false);
        judgeAutoReportVerifyProgressAndActualValueComRespDto = taskService.judgeAutoReportVerifyProgressAndActualValueCom(judgeAutoReportVerifyProgressAndActualValueComReqDto)/*vcase invoke isSameApp*/;


        judgeAutoReportVerifyProgressAndActualValueComRespDto_1 = judgeAutoReportVerifyProgressAndActualValueComRespDto;
//virtualUsage D3-查询上一个执行周期的周期及目标周期详情(公共)  59744
        QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
        QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto = new QueryLastExecCycleAndTargetCycleDetailComReqDto();
        if (reqDto != null) {
            queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1489206_1_59744
            queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489207_1_59744
            queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1489208_1_59744
        }

        /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(), "D3-执行自动汇报标准数据准备(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(), "D3-执行自动汇报标准数据准备(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空", false);
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(), "D3-执行自动汇报标准数据准备(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空", false);
        queryLastExecCycleAndTargetCycleDetailComRespDto = executeCycleService.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


        if ((judgeAutoReportVerifyProgressAndActualValueComRespDto != null && judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateProgressStandardData() != null && judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateProgressStandardData().equals("CREATE_PROGRESS_VALUE"))) {
            //if(D3-判断自动汇报校验进度值与实际值(公共).是否新增进度值标准数据 等于 新增进度值)  59604

            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            if (queryLastExecCycleAndTargetCycleDetailComRespDto != null && judgeAutoReportVerifyProgressAndActualValueComRespDto != null) {
                QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
                queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:1489652_1_59751
                queryStandardDataDetailComReqDto.setIsUpdateCycleNewData("TRUE");//sourceId:1489666_1_59751
                queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1489667_1_59751
                queryStandardDataDetailComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1489642_1_59751
                queryStandardDataDetailComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1489659_1_59751
                queryStandardDataDetailComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1489646_1_59751
                queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1489647_1_59751
                if (receptionServiceRes != null) {
                    queryStandardDataDetailComReqDto.setDataType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1489645_1_59751
                }
                if (queryLastExecCycleAndTargetCycleDetailComRespDto != null) {
                    queryStandardDataDetailComReqDto.setPeriodId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1489654_1_59751
                    queryStandardDataDetailComReqDto.setEntityId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1489643_1_59751
                }
                if (reqDto != null) {
                    queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1489660_1_59751
                }
                if (judgeAutoReportVerifyProgressAndActualValueComRespDto != null) {
                    queryStandardDataDetailComReqDto.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489655_1_59751
                    queryStandardDataDetailComReqDto.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489656_1_59751
                    queryStandardDataDetailComReqDto.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489693_1_59751
                    queryStandardDataDetailComReqDto.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489663_1_59751
                }

                /*D4-1查标准数据详情(公共)[2695]   */
                Assert.isNull(queryStandardDataDetailComReqDto.getDataType(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getIsUpdateCycleNewData(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否更新周期最新数据不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据使用场景编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getTableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getPersonLiableObjId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getBizRoleObjCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getPersonLiableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getBelongToPersonalIdentityId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据归属个人ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getParentSubMidCycleType(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-父子中周期类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
                queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            RefreshAutoReportStandardDataComRespDto refreshAutoReportStandardDataComRespDto = null;
            if (judgeAutoReportVerifyProgressAndActualValueComRespDto != null && queryStandardDataDetailComRespDto != null) {
                RefreshAutoReportStandardDataComReqDto refreshAutoReportStandardDataComReqDto = new RefreshAutoReportStandardDataComReqDto();
                refreshAutoReportStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1489096_1_59741
                if (receptionServiceRes != null) {
                    refreshAutoReportStandardDataComReqDto.setDataType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1489080_1_59741
                }
                if (judgeAutoReportVerifyProgressAndActualValueComRespDto != null) {
                    refreshAutoReportStandardDataComReqDto.setDataResult(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1489081_1_59741
                    refreshAutoReportStandardDataComReqDto.setUnit(judgeAutoReportVerifyProgressAndActualValueComRespDto.getUnit());//SimpleFieldAssign//sourceId:1489082_1_59741
                    refreshAutoReportStandardDataComReqDto.setUpdateCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489086_1_59741
                    refreshAutoReportStandardDataComReqDto.setUpdateCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489087_1_59741
                    refreshAutoReportStandardDataComReqDto.setUpdateCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489088_1_59741
                    refreshAutoReportStandardDataComReqDto.setCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489090_1_59741
                    refreshAutoReportStandardDataComReqDto.setCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489091_1_59741
                    refreshAutoReportStandardDataComReqDto.setCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489092_1_59741
                    refreshAutoReportStandardDataComReqDto.setCycleTypeInstanceCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1489093_1_59741
                    refreshAutoReportStandardDataComReqDto.setIsWorkCycleData(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1489094_1_59741
                    refreshAutoReportStandardDataComReqDto.setWorkCycleUpdateSlice(judgeAutoReportVerifyProgressAndActualValueComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1489095_1_59741
                    refreshAutoReportStandardDataComReqDto.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489097_1_59741
                    refreshAutoReportStandardDataComReqDto.setStandardDataCalcCycleModel(judgeAutoReportVerifyProgressAndActualValueComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1489098_1_59741
                    refreshAutoReportStandardDataComReqDto.setIsSystemDocking(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsSystemDocking());//SimpleFieldAssign//sourceId:1489099_1_59741
                    refreshAutoReportStandardDataComReqDto.setDataUsageSceneCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1489100_1_59741
                    refreshAutoReportStandardDataComReqDto.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489101_1_59741
                    refreshAutoReportStandardDataComReqDto.setPersonLiableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1489104_1_59741
                    refreshAutoReportStandardDataComReqDto.setBizRoleObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1489102_1_59741
                    refreshAutoReportStandardDataComReqDto.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489105_1_59741
                    refreshAutoReportStandardDataComReqDto.setBizRoleObjName(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1489103_1_59741
                    refreshAutoReportStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1489115_1_59741
                    refreshAutoReportStandardDataComReqDto.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489116_1_59741
                    refreshAutoReportStandardDataComReqDto.setTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1489108_1_59741
                    refreshAutoReportStandardDataComReqDto.setEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1489113_1_59741
                    refreshAutoReportStandardDataComReqDto.setBelongToContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1489110_1_59741
                    refreshAutoReportStandardDataComReqDto.setBelongToContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1489111_1_59741
                    refreshAutoReportStandardDataComReqDto.setCategoryContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCategoryContentTypeCode());//SimpleFieldAssign//sourceId:1489118_1_59741
                    refreshAutoReportStandardDataComReqDto.setTopTargetCategoryID(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTopTargetCategoryID());//SimpleFieldAssign//sourceId:1489119_1_59741
                    refreshAutoReportStandardDataComReqDto.setThemeContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1489106_1_59741
                    refreshAutoReportStandardDataComReqDto.setThemeContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentId());//SimpleFieldAssign//sourceId:1489107_1_59741
                    refreshAutoReportStandardDataComReqDto.setFromContentTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1489109_1_59741
                    refreshAutoReportStandardDataComReqDto.setFromContentEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1489114_1_59741
                }
                if (queryStandardDataDetailComRespDto != null) {
                    refreshAutoReportStandardDataComReqDto.setParentDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1489083_1_59741
                    refreshAutoReportStandardDataComReqDto.setParentDataResult(queryStandardDataDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1489084_1_59741
                }
                if (reqDto != null) {
                    refreshAutoReportStandardDataComReqDto.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489085_1_59741
                    refreshAutoReportStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489089_1_59741
                }

                /*D4-更新自动汇报更新标准数据(公共)[8305]   */
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getDataType(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getDataResult(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据值结果不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getUnit(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-冗余单位不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleStartTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期开始时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleEndTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期结束时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期类型标识不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleStartTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期开始时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleEndTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期结束时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期类型标识不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getIsWorkCycleData(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否工作周期数据不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getWorkCycleUpdateSlice(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-工作周期更新切片不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getParentSubMidCycleType(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-父子中周期类型不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getStandardDataCalcCycleModel(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-标准数据计算周期模型不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getIsSystemDocking(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否系统对接不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getResultType(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-结果产生类型 不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getDataUsageSceneCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据使用场景编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getPersonLiableObjId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getPersonLiableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBizRoleObjId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBizRoleObjCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBizRoleObjName(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToPersonalIdentityId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getTableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getEntityId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToContentId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getCategoryContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-目标分类类型表类型不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getTopTargetCategoryID(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-一级目标分类ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getThemeContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto.getThemeContentId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容ID不能为空", false);
                refreshAutoReportStandardDataComRespDto = fwCalcStandardDataClient.refreshAutoReportStandardDataCom(refreshAutoReportStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        if ((judgeAutoReportVerifyProgressAndActualValueComRespDto != null && judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateActualStandardData() != null && judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateActualStandardData().equals("CREATE_ACTUAL_VALUE"))) {
            //if(D3-判断自动汇报校验进度值与实际值(公共).是否新增实际值标准数据 等于 新增实际值)  59606

            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_2 = null;
            if (queryLastExecCycleAndTargetCycleDetailComRespDto != null && judgeAutoReportVerifyProgressAndActualValueComRespDto != null) {
                QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_1 = new QueryStandardDataDetailComReqDto();
                queryStandardDataDetailComReqDto_1.setIsNewData("TRUE");//sourceId:1489652_1_59752
                queryStandardDataDetailComReqDto_1.setIsUpdateCycleNewData("TRUE");//sourceId:1489666_1_59752
                queryStandardDataDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1489667_1_59752
                queryStandardDataDetailComReqDto_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1489642_1_59752
                queryStandardDataDetailComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1489659_1_59752
                queryStandardDataDetailComReqDto_1.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1489646_1_59752
                queryStandardDataDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1489647_1_59752
                if (receptionServiceRes != null) {
                    queryStandardDataDetailComReqDto_1.setDataType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1489645_1_59752
                }
                if (queryLastExecCycleAndTargetCycleDetailComRespDto != null) {
                    queryStandardDataDetailComReqDto_1.setPeriodId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1489654_1_59752
                    queryStandardDataDetailComReqDto_1.setEntityId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1489643_1_59752
                }
                if (reqDto != null) {
                    queryStandardDataDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1489660_1_59752
                }
                if (judgeAutoReportVerifyProgressAndActualValueComRespDto != null) {
                    queryStandardDataDetailComReqDto_1.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489655_1_59752
                    queryStandardDataDetailComReqDto_1.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489656_1_59752
                    queryStandardDataDetailComReqDto_1.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489693_1_59752
                    queryStandardDataDetailComReqDto_1.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489663_1_59752
                }

                /*D4-1查标准数据详情(公共)[2695]   */
                Assert.isNull(queryStandardDataDetailComReqDto_1.getDataType(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getPeriodId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getIsNewData(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getIsUpdateCycleNewData(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否更新周期最新数据不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getDataUsageSceneCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据使用场景编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getTableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getEntityId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getThemeContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getThemeContentId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getPersonLiableObjId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getBizRoleObjCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getPersonLiableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getBelongToPersonalIdentityId(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据归属个人ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getParentSubMidCycleType(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-父子中周期类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getSubjectLifeCycle(), "D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
                queryStandardDataDetailComRespDto_2 = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            RefreshAutoReportStandardDataComRespDto refreshAutoReportStandardDataComRespDto_1 = null;
            if (judgeAutoReportVerifyProgressAndActualValueComRespDto != null && queryStandardDataDetailComRespDto_2 != null) {
                RefreshAutoReportStandardDataComReqDto refreshAutoReportStandardDataComReqDto_1 = new RefreshAutoReportStandardDataComReqDto();
                refreshAutoReportStandardDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1489096_1_59742
                if (receptionServiceRes != null) {
                    refreshAutoReportStandardDataComReqDto_1.setDataType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1489080_1_59742
                }
                if (judgeAutoReportVerifyProgressAndActualValueComRespDto != null) {
                    refreshAutoReportStandardDataComReqDto_1.setDataResult(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1489081_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setUnit(judgeAutoReportVerifyProgressAndActualValueComRespDto.getUnit());//SimpleFieldAssign//sourceId:1489082_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setUpdateCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489086_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setUpdateCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489087_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setUpdateCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489088_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489090_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489091_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489092_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setCycleTypeInstanceCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1489093_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setIsWorkCycleData(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1489094_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setWorkCycleUpdateSlice(judgeAutoReportVerifyProgressAndActualValueComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1489095_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489097_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setStandardDataCalcCycleModel(judgeAutoReportVerifyProgressAndActualValueComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1489098_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setIsSystemDocking(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsSystemDocking());//SimpleFieldAssign//sourceId:1489099_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setDataUsageSceneCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1489100_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489101_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setPersonLiableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1489104_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBizRoleObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1489102_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489105_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBizRoleObjName(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1489103_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBelongToPersonalIdentityTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1489115_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489116_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1489108_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1489113_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBelongToContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1489110_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setBelongToContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1489111_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setCategoryContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCategoryContentTypeCode());//SimpleFieldAssign//sourceId:1489118_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setTopTargetCategoryID(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTopTargetCategoryID());//SimpleFieldAssign//sourceId:1489119_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setThemeContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1489106_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setThemeContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentId());//SimpleFieldAssign//sourceId:1489107_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setFromContentTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1489109_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setFromContentEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1489114_1_59742
                }
                if (queryStandardDataDetailComRespDto_2 != null) {
                    refreshAutoReportStandardDataComReqDto_1.setParentDataResultId(queryStandardDataDetailComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:1489083_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setParentDataResult(queryStandardDataDetailComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1489084_1_59742
                }
                if (reqDto != null) {
                    refreshAutoReportStandardDataComReqDto_1.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489085_1_59742
                    refreshAutoReportStandardDataComReqDto_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489089_1_59742
                }

                /*D4-更新自动汇报更新标准数据(公共)[8305]   */
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getDataType(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getDataResult(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据值结果不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUnit(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-冗余单位不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleStartTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期开始时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleEndTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期结束时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期类型标识不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleStartTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期开始时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleEndTime(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期结束时间不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期类型标识不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getIsWorkCycleData(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否工作周期数据不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getWorkCycleUpdateSlice(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-工作周期更新切片不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getParentSubMidCycleType(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-父子中周期类型不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getStandardDataCalcCycleModel(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-标准数据计算周期模型不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getIsSystemDocking(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否系统对接不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getResultType(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-结果产生类型 不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getDataUsageSceneCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据使用场景编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getPersonLiableObjId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人对象ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getPersonLiableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人身份类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBizRoleObjId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBizRoleObjCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色标识不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBizRoleObjName(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象名称不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToPersonalIdentityTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人身份类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToPersonalIdentityId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getTableTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getEntityId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToContentId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表主键ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCategoryContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-目标分类类型表类型不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getTopTargetCategoryID(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-一级目标分类ID不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getThemeContentTypeCode(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容类型编码不能为空", false);
                Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getThemeContentId(), "D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容ID不能为空", false);
                refreshAutoReportStandardDataComRespDto_1 = fwCalcStandardDataClient.refreshAutoReportStandardDataCom(refreshAutoReportStandardDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        ImplementAutoReportStandardDataComRespDto retData = new ImplementAutoReportStandardDataComRespDto();
        if (judgeAutoReportVerifyProgressAndActualValueComRespDto_1 != null) {
            retData.setAutoReportProgressValueVerify(judgeAutoReportVerifyProgressAndActualValueComRespDto_1.getAutoReportProgressValueVerify());//SimpleFieldAssign//sourceId:1489971_1
            retData.setAutoReportActualValueVerify(judgeAutoReportVerifyProgressAndActualValueComRespDto_1.getAutoReportActualValueVerify());//SimpleFieldAssign//sourceId:1489972_1
        }


        return retData;
    }

    /**
     * D3执行循环增祖先目标周期资金来源预算标准数据(公共)[7715]
     * gen by moon at 1/31/2024, 8:44:54 PM
     */
    @Trace(operationName = "D3执行循环增祖先目标周期资金来源预算标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto implementLoopAddAncestorContTargetCycleBudgetDataCom(ImplementLoopAddAncestorContTargetCycleBudgetDataComReqDto reqDto) {


        if ((reqDto != null && reqDto.getFinanceAccountList() != null && reqDto.getFinanceAccountList().size() > 0)) {
            //if(D4执行循环增祖先目标内容目标周期预算标准数据(公共).资金账户列表数据集条数 大于 0)  52014

//ModelCode: circulationCollections
            for (String circulationCollectionsRes : reqDto.getFinanceAccountList()) {

                QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
                QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto = new QueryFinanceAccountDetailComReqDto();
                queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1512615_1_60379
                queryFinanceAccountDetailComReqDto.setIsStatisticalAccount("TRUE");//sourceId:1512616_1_60379
                queryFinanceAccountDetailComReqDto.setIsArchive("FALSE");//sourceId:1512618_1_60379
                queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1512619_1_60379
                if (circulationCollectionsRes != null) {
                    queryFinanceAccountDetailComReqDto.setAccountObjectId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1512617_1_60379
                }

                /*D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)[7681]   */
                Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-是否预算账户不能为空", false);
                Assert.isNull(queryFinanceAccountDetailComReqDto.getIsStatisticalAccount(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-是否统计账户不能为空", false);
                Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-关联归属主体ID不能为空", false);
                Assert.isNull(queryFinanceAccountDetailComReqDto.getIsArchive(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-是否存档不能为空", false);
                Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-创建于空间ID不能为空", false);
                queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                QueryEvaObjTargetCycleDetailComRespDto queryEvaObjTargetCycleDetailComRespDto = null;
                QueryEvaObjTargetCycleDetailComReqDto queryEvaObjTargetCycleDetailComReqDto = new QueryEvaObjTargetCycleDetailComReqDto();
                queryEvaObjTargetCycleDetailComReqDto.setIsArchive("FALSE");//sourceId:1244496_1_52018
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1244492_1_52018
                    queryEvaObjTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244494_1_52018
                    queryEvaObjTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1244495_1_52018
                }
                if (circulationCollectionsRes != null) {
                    queryEvaObjTargetCycleDetailComReqDto.setTargetCycleContentId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1244493_1_52018
                }

                /*D3查当前牌目标周期(用于增标准数据入参)[3489]   */
                Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaObjEntityId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getTargetCycleContentId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-关联目标内容ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getCycleId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaluationTemplateId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getIsArchive(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-是否存档不能为空", false);
                queryEvaObjTargetCycleDetailComRespDto = targetCycleService.queryEvaObjTargetCycleDetailCom(queryEvaObjTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


                ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
                if (queryEvaObjTargetCycleDetailComRespDto != null) {
                    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto = new ImplementContentTypeChangeTableTypeComReqDto();
                    if (queryEvaObjTargetCycleDetailComRespDto != null) {
                        implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCycleDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244598_1_52020
                    }

                    /*D3内容类型转表类型(公共)[5354]   */
                    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3内容类型转表类型(公共)-关联目标内容类型编码不能为空", false);
                    implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


                }
                ImplementDataResultAddOrReductionComRespDto implementDataResultAddOrReductionComRespDto = null;
                if (queryEvaObjTargetCycleDetailComRespDto != null && implementContentTypeChangeTableTypeComRespDto != null && queryFinanceAccountDetailComRespDto != null) {
                    ImplementDataResultAddOrReductionComReqDto implementDataResultAddOrReductionComReqDto = new ImplementDataResultAddOrReductionComReqDto();
                    implementDataResultAddOrReductionComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1512474_1_60373
                    implementDataResultAddOrReductionComReqDto.setIsWorkCycleData("TRUE");//sourceId:1512488_1_60373
                    implementDataResultAddOrReductionComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1512490_1_60373
                    implementDataResultAddOrReductionComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1512503_1_60373
                    implementDataResultAddOrReductionComReqDto.setCalcStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1512506_1_60373
                    implementDataResultAddOrReductionComReqDto.setUpdateBatch(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1512507_1_60373
                    if (reqDto != null) {
                        implementDataResultAddOrReductionComReqDto.setBillTypeCode(reqDto.getBillTypeCode());//SimpleFieldAssign//sourceId:1512472_1_60373
                        implementDataResultAddOrReductionComReqDto.setDataUsageSceneCode(reqDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1512487_1_60373
                        implementDataResultAddOrReductionComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1512489_1_60373
                        implementDataResultAddOrReductionComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1512473_1_60373
                        implementDataResultAddOrReductionComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1512475_1_60373
                        implementDataResultAddOrReductionComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1512476_1_60373
                        implementDataResultAddOrReductionComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1512502_1_60373
                        implementDataResultAddOrReductionComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1512504_1_60373
                        implementDataResultAddOrReductionComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1512492_1_60373
                        implementDataResultAddOrReductionComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1512496_1_60373
                        implementDataResultAddOrReductionComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1512493_1_60373
                        implementDataResultAddOrReductionComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1512494_1_60373
                        implementDataResultAddOrReductionComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1512495_1_60373
                        implementDataResultAddOrReductionComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1512498_1_60373
                        implementDataResultAddOrReductionComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1512499_1_60373
                        implementDataResultAddOrReductionComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1512497_1_60373
                    }
                    if (queryEvaObjTargetCycleDetailComRespDto != null) {
                        implementDataResultAddOrReductionComReqDto.setPeriodId(queryEvaObjTargetCycleDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1512477_1_60373
                        implementDataResultAddOrReductionComReqDto.setCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1512478_1_60373
                        implementDataResultAddOrReductionComReqDto.setCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1512479_1_60373
                        implementDataResultAddOrReductionComReqDto.setCycleTypeCode(queryEvaObjTargetCycleDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1512480_1_60373
                        implementDataResultAddOrReductionComReqDto.setCycleTypeInstanceCode(queryEvaObjTargetCycleDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1512481_1_60373
                        implementDataResultAddOrReductionComReqDto.setUpdateCycleId(queryEvaObjTargetCycleDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1512482_1_60373
                        implementDataResultAddOrReductionComReqDto.setUpdateCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1512483_1_60373
                        implementDataResultAddOrReductionComReqDto.setUpdateCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1512484_1_60373
                        implementDataResultAddOrReductionComReqDto.setUpdateCycleTypeCode(queryEvaObjTargetCycleDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1512485_1_60373
                        implementDataResultAddOrReductionComReqDto.setEntityId(queryEvaObjTargetCycleDetailComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1512491_1_60373
                        implementDataResultAddOrReductionComReqDto.setBelongToContentId(queryEvaObjTargetCycleDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1512501_1_60373
                    }
                    if (implementContentTypeChangeTableTypeComRespDto != null) {
                        implementDataResultAddOrReductionComReqDto.setBelongToContentTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1512500_1_60373
                    }
                    if (queryFinanceAccountDetailComRespDto != null) {
                        implementDataResultAddOrReductionComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1512505_1_60373
                    }

                    /*D4新增预算资金来源祖先当前牌标准数据(公共)[8365]   */
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getBillTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-收支类型不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getDataUsageSceneCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据使用场景编码不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getResultType(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-结果产生类型 不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getDataType(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据类型编码不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getDataResult(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据值结果不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getUnit(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-冗余单位不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getPeriodId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期ID不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getCycleStartTime(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期开始时间不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getCycleEndTime(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期结束时间不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getCycleTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期类型标识不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期ID不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleStartTime(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期开始时间不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleEndTime(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期结束时间不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期类型标识不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getIsWorkCycleData(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-是否工作周期数据不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getParentSubMidCycleType(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-父子中周期类型不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getTableTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-归属内容表类型编码不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getEntityId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getBelongToContentTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据归属内容表类型编码不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getBelongToContentId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据归属内容表主键ID不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getExtendedField3(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-扩展字段3不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getThemeContentTypeCode(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-主题内容类型编码不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getThemeContentId(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-主题内容ID不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getSubjectLifeCycle(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-主体生命周期不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getCalcStartTime(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-计算开始时间不能为空", false);
                    Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateBatch(), "D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据更新批次（时间点）不能为空", false);
                    implementDataResultAddOrReductionComRespDto = fwCalcStandardDataClient.implementDataResultAddOrReductionCom(implementDataResultAddOrReductionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto retData = new ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto();


        return retData;
    }

    /**
     * D3-提交预算支出标准数据(公共)[8372]
     * gen by moon at 1/31/2024, 8:46:10 PM
     */
    @Trace(operationName = "D3-提交预算支出标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CommitBudgetDisburseStandardDataComRespDto commitBudgetDisburseStandardDataCom(CommitBudgetDisburseStandardDataComReqDto reqDto) {


        //步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
        //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
        ImplementFourthReceivingFieldReqDto receptionServiceReq = new ImplementFourthReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1515014_1
            receptionServiceReq.setLastEvaObjTargetCycleId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1515039_1
            receptionServiceReq.setLastCycleId(reqDto.getLastCycleId());//SimpleFieldAssign//sourceId:1515038_1
            receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1515040_1
            receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1515021_1
            receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1515022_1
            receptionServiceReq.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1515023_1
            receptionServiceReq.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1515025_1
            receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1515043_1
            receptionServiceReq.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1515045_1
            receptionServiceReq.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1515042_1
            receptionServiceReq.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1515030_1
            receptionServiceReq.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1515031_1
            receptionServiceReq.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1515032_1
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514941_1
            receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1515073_1
            receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1515113_1
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514972_1
            receptionServiceReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1515046_1
            receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1515047_1
            receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1515114_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514939_1
            receptionServiceReq.setExtendedField2(reqDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1515074_1
            receptionServiceReq.setExtendedField3(reqDto.getContnetAccountSubjectld());//SimpleFieldAssign//sourceId:1515075_1
        }

        /*M3-接收入参字段[8259]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDataResult(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-数据值结果不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期结束时间不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleTypeCode(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期类型标识不能为空", false);
        Assert.isNull(receptionServiceReq.getIsWorkCycleData(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-是否工作周期数据不能为空", false);
        Assert.isNull(receptionServiceReq.getParentSubMidCycleType(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-父子中周期类型不能为空", false);
        Assert.isNull(receptionServiceReq.getStandardDataCalcCycleModel(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-标准数据计算周期模型不能为空", false);
        Assert.isNull(receptionServiceReq.getWorkCycleUpdateSlice(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-工作周期更新切片不能为空", false);
        Assert.isNull(receptionServiceReq.getBizRoleObjId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(receptionServiceReq.getBizRoleObjCode(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(receptionServiceReq.getBizRoleObjName(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-填报评价责任人业务角色对象名称不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-被评对象目标周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-关联目标内容类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-关联目标内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getBelongToContentTypeCode(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-数据归属内容表类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getBelongToContentId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-数据归属内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-冗余目标ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3-提交预算支出标准数据(公共)-M3-接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbStandardData.implementFourthReceivingField(receptionServiceReq);


//步骤1: D3-执行提交预算条件分析(公共) - implementSubmitBudgetAnalyzeCom
        ImplementSubmitBudgetAnalyzeComRespDto implementSubmitBudgetAnalyzeComRespDto = null;
        ImplementSubmitBudgetAnalyzeComReqDto implementSubmitBudgetAnalyzeComReqDto = new ImplementSubmitBudgetAnalyzeComReqDto();
        if (reqDto != null) {
//      implementSubmitBudgetAnalyzeComReqDto.setBudget(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1515112_1
//implementSubmitBudgetAnalyzeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1515108_1
            implementSubmitBudgetAnalyzeComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1515109_1
//implementSubmitBudgetAnalyzeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1515110_1
            implementSubmitBudgetAnalyzeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1515111_1
        }

        /*D3-执行提交预算条件分析（异常或不满足条件报错）[7704]   */
//    Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getBudget(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-预算金额不能为空",false);
//Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetCycleContentTypeCode(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-关联目标内容类型编码不能为空",false);
        Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetCycleContentId(), "D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-关联目标内容ID不能为空", false);
//Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetId(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-冗余目标ID不能为空",false);
        Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getEvaluationTemplateId(), "D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-冗余评价模板ID不能为空", false);
        implementSubmitBudgetAnalyzeComRespDto = financeService.implementSubmitBudgetAnalyzeCom(implementSubmitBudgetAnalyzeComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2-3查询分组匹配结果转答案(公共)(跨服务） - queryClassMatchResultToAnswerDetailCom
        QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
        QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto = new QueryClassMatchResultToAnswerDetailComReqDto();
        queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1514726_1
        queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("UNIT_CONFIG_CLASS");//CUSTOM_CONVENTION//sourceId:1514693_1
        queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1514772_1

        /*D2-3查预算金额单位（用于新增标准数据）[3088]   */
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D3-提交预算支出标准数据(公共)-D2-3查预算金额单位（用于新增标准数据）-开通对象ID不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(), "D3-提交预算支出标准数据(公共)-D2-3查预算金额单位（用于新增标准数据）-分组标识不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3-提交预算支出标准数据(公共)-D2-3查预算金额单位（用于新增标准数据）-是否标准答案不能为空", false);
        queryClassMatchResultToAnswerDetailComRespDto = confSchemeService.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤3: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514961_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514959_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514960_1
        }

        /*3-3-09查目标周期详情（获取周期信息用于新增标准数据）[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-提交预算支出标准数据(公共)-3-3-09查目标周期详情（获取周期信息用于新增标准数据）-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-提交预算支出标准数据(公共)-3-3-09查目标周期详情（获取周期信息用于新增标准数据）-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3-提交预算支出标准数据(公共)-3-3-09查目标周期详情（获取周期信息用于新增标准数据）-主体生命周期不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤4: D7-查询资金账户详情(公共) - queryFinanceAccountDetailCom
        QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
        if (implementSubmitBudgetAnalyzeComRespDto != null) {
            QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto = new QueryFinanceAccountDetailComReqDto();
            queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1514968_1
            queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514970_1
            queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1514971_1
            if (implementSubmitBudgetAnalyzeComRespDto != null) {
//      queryFinanceAccountDetailComReqDto.setAccountObjectId(implementSubmitBudgetAnalyzeComRespDto.getAccountObjectId());//SimpleFieldAssign//sourceId:1514969_1
            }

            /*D7-查询预算账户ID（用于新增标准数据）[7681]   */
            Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(), "D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-关联归属主体ID不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(), "D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-是否预算账户不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(), "D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-主体生命周期不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(), "D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-创建于空间ID不能为空", false);
            queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

//步骤5: D4-1提交标准数据(公共) - commitStandardDataCom
        CommitStandardDataComRespDto commitStandardDataComRespDto = null;
        if (queryClassMatchResultToAnswerDetailComRespDto != null) {
            CommitStandardDataComReqDto commitStandardDataComReqDto = new CommitStandardDataComReqDto();
            commitStandardDataComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1514905_1
            commitStandardDataComReqDto.setResultType("MANUAL_INPUT");//sourceId:1514906_1
            commitStandardDataComReqDto.setPersonLiableObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1514915_1
            commitStandardDataComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514916_1
            commitStandardDataComReqDto.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514934_1
            commitStandardDataComReqDto.setBelongToPersonalIdentityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1514935_1
            commitStandardDataComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514933_1
            commitStandardDataComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514900_1
            commitStandardDataComReqDto.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514901_1
            commitStandardDataComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514923_1
            commitStandardDataComReqDto.setSubjectLifeCycle("EDITING");//sourceId:1514920_1
            if (reqDto != null) {
                commitStandardDataComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1514903_1
//commitStandardDataComReqDto.setLastEvaObjTargetCycleId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514907_1
//commitStandardDataComReqDto.setLastCycleId(reqDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514908_1
                commitStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514925_1
                commitStandardDataComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514930_1
                commitStandardDataComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514931_1
                commitStandardDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514927_1
                commitStandardDataComReqDto.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514932_1
                commitStandardDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514909_1
                commitStandardDataComReqDto.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514929_1
                commitStandardDataComReqDto.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514928_1
                commitStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1514917_1
                commitStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1514919_1
                commitStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1514918_1
//commitStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514899_1
//commitStandardDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514902_1
                commitStandardDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1514921_1
                commitStandardDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1514922_1
                commitStandardDataComReqDto.setRootTargetCategoryId(reqDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514926_1
                commitStandardDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514924_1
                commitStandardDataComReqDto.setExtendedField3(reqDto.getContnetAccountSubjectld());//SimpleFieldAssign//sourceId:1514936_1
            }
            if (queryClassMatchResultToAnswerDetailComRespDto != null) {
//      commitStandardDataComReqDto.setUnit(queryClassMatchResultToAnswerDetailComRespDto.getCashAccountUnit());//SimpleFieldAssign//sourceId:1514904_1
            }
            if (omsEvaluationObjectTargetCycle != null) {
                commitStandardDataComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1514910_1
                commitStandardDataComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1514911_1
                commitStandardDataComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1514912_1
                commitStandardDataComReqDto.setCycleTypeCode(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514913_1
                commitStandardDataComReqDto.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514914_1
            }
            if (queryFinanceAccountDetailComRespDto != null) {
                commitStandardDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514937_1
            }

            /*D4-1提交标准数据（预算支出金额）[5640]   */
            Assert.isNull(commitStandardDataComReqDto.getDataResult(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据值结果不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getUnit(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-冗余单位不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getDataType(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据类型编码不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getResultType(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-结果产生类型 不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getUpdateCycleId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-更新周期ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getCycleId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getCycleStartTime(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期开始时间不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getCycleEndTime(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期结束时间不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getCycleTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期类型标识不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getIsWorkCycleData(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-是否工作周期数据不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getParentSubMidCycleType(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-父子中周期类型不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getStandardDataCalcCycleModel(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-标准数据计算周期模型不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getWorkCycleUpdateSlice(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-工作周期更新切片不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getPersonLiableObjId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人对象ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getPersonLiableTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人身份类型编码不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getBizRoleObjId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人业务角色对象ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getBizRoleObjCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人业务角色标识不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getBizRoleObjName(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人业务角色对象名称不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属个人身份类型编码不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getBelongToPersonalIdentityId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属个人ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getDataUsageSceneCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据使用场景编码不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getTableTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-归属内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-被评对象目标周期ID不能为空",false);
            Assert.isNull(commitStandardDataComReqDto.getFromContentTableTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-来自内容表类型编码不能为空", false);
//Assert.isNull(commitStandardDataComReqDto.getCycleStageDataId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期阶段资料记录ID不能为空",false);
            Assert.isNull(commitStandardDataComReqDto.getBelongToContentTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属内容表类型编码不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getBelongToContentId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属内容表主键ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getRootTargetCategoryId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-冗余一级目标分类ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getThemeContentTypeCode(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-主题内容类型编码不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getThemeContentId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-主题内容ID不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getSubjectLifeCycle(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-主体生命周期不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getExtendedField3(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-扩展字段3不能为空", false);
            Assert.isNull(commitStandardDataComReqDto.getAccountId(), "D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-归属账户ID不能为空", false);
            commitStandardDataComRespDto = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

        CommitBudgetDisburseStandardDataComRespDto retData = new CommitBudgetDisburseStandardDataComRespDto();


        return retData;
    }

    /**
     * D3-提交预算支出数据准备(公共)[8372]
     * gen by moon at 3/13/2024, 5:22:33 AM
     */
    @Trace(operationName = "D3-提交预算支出数据准备(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CommitReadyForCommitActualValueAndBudgetStandardDataComRespDto commitReadyForCommitActualValueAndBudgetStandardDataCom(CommitReadyForCommitActualValueAndBudgetStandardDataComReqDto reqDto) {


        QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_1 = null;
        if ((reqDto != null && reqDto.getBudgetDisburse() != null)) {
            //if(D3-提交实际值及预算支出数据准备(公共).预算支出金额 值不等于空 )  60441

            QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
            QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto = new QueryFinanceAccountDetailComReqDto();
            queryFinanceAccountDetailComReqDto.setAccountStatus("NORMAL");//sourceId:1562157_1_60444
            queryFinanceAccountDetailComReqDto.setAccountTypeCode("ECOLOGICAL_ACCOUNT");//sourceId:1562207_1_60444
            queryFinanceAccountDetailComReqDto.setEcologicalAccountTypeCode("TARGET_CONTENT_ACCOUNT");//sourceId:1562209_1_60444
            queryFinanceAccountDetailComReqDto.setIsBudgetAccount("FALSE");//sourceId:1514968_1_60444
            queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514970_1_60444
            queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1514971_1_60444
            if (reqDto != null) {
                queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514969_1_60444
            }

            /*D7-查实体账户详情（获取关联扣减的预算账户标识）[7681]   */
            Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-关联归属主体ID不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountStatus(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-账户状态不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountTypeCode(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-账户类型不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getEcologicalAccountTypeCode(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-生态账户类型编码不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-是否预算账户不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-主体生命周期不能为空", false);
            Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(), "D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-创建于空间ID不能为空", false);
            queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            queryFinanceAccountDetailComRespDto_1 = queryFinanceAccountDetailComRespDto;
        }
        CommitReadyForCommitActualValueAndBudgetStandardDataComRespDto retData = new CommitReadyForCommitActualValueAndBudgetStandardDataComRespDto();
        if (queryFinanceAccountDetailComRespDto_1 != null) {
            retData.setAccountId(queryFinanceAccountDetailComRespDto_1.getAccountId());//SimpleFieldAssign//sourceId:1580799_1
        }


        return retData;
    }

    /**
     * D3准备目标内容周期与相关人等入参数据(公共)[8539]
     * gen by moon at 5/22/2024, 2:41:01 PM
     */
    @Trace(operationName = "D3准备目标内容周期与相关人等入参数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public PreparationTargetCycleAndPeopleEternalGinsengComRespDto preparationTargetCycleAndPeopleEternalGinsengCom(PreparationTargetCycleAndPeopleEternalGinsengComReqDto reqDto) {


        ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto_1 = null;
        PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengComRespDto_1 = null;
        ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto_1 = null;
        ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto_1 = null;
        PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto_1 = null;
//virtualUsage D3内容类型转表类型(公共)  62163
        ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
        ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto = new ImplementContentTypeChangeTableTypeComReqDto();
        if (reqDto != null) {
            implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1567247_1_62163
        }

        /*D3内容类型转表类型(公共)[5354]   */
        Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(), "D3准备目标内容周期与相关人等入参数据(公共)-D3内容类型转表类型(公共)-关联目标内容类型编码不能为空", false);
        implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


        implementContentTypeChangeTableTypeComRespDto_1 = implementContentTypeChangeTableTypeComRespDto;
        if ((reqDto != null && reqDto.getIsFinanceStandardData() != null && reqDto.getIsFinanceStandardData().equals("TRUE"))) {
            //if(D3准备目标内容周期与相关人等入参数据(公共).是否财务标准数据 等于 是)  61959

            if ((reqDto != null && reqDto.getIsParentCycle() == null || reqDto != null && reqDto.getEvaObjTargetCycleId() != null || reqDto != null && reqDto.getCycleId() != null)) {
                //if((D3准备目标内容周期与相关人等入参数据(公共).是否父周期 值等于空  or D3准备目标内容周期与相关人等入参数据(公共).被评对象目标周期ID 值不等于空  or D3准备目标内容周期与相关人等入参数据(公共).周期ID 值不等于空 ))  61966

//异常结束 61967
                throw new BizException("C00028", "对不起，没有数据！！", false);
            }
            PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengComRespDto = null;
            PreparationTargetCycleEternalGinsengComReqDto preparationTargetCycleEternalGinsengComReqDto = new PreparationTargetCycleEternalGinsengComReqDto();
            if (reqDto != null) {
                preparationTargetCycleEternalGinsengComReqDto.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1563437_1_61963
                preparationTargetCycleEternalGinsengComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563439_1_61963
                preparationTargetCycleEternalGinsengComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563440_1_61963
            }

            /*D3准备目标内容周期等入参数据(公共)[8541]   */
            Assert.isNull(preparationTargetCycleEternalGinsengComReqDto.getTargetCycleContentId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(preparationTargetCycleEternalGinsengComReqDto.getEvaluationTemplateId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-冗余评价模板ID不能为空", false);
            preparationTargetCycleEternalGinsengComRespDto = preparationTargetCycleEternalGinsengCom(preparationTargetCycleEternalGinsengComReqDto)/*vcase invoke 同服务,同domain*/;


            preparationTargetCycleEternalGinsengComRespDto_1 = preparationTargetCycleEternalGinsengComRespDto;
            ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto = null;
            ObtainTargetContNatureInfoComReqDto obtainTargetContNatureInfoComReqDto = new ObtainTargetContNatureInfoComReqDto();
            if (reqDto != null) {
                obtainTargetContNatureInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1565730_1_62034
                obtainTargetContNatureInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1565731_1_62034
                obtainTargetContNatureInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1565732_1_62034
            }

            /*D3获取目标内容属性信息(公共)[6952]   */
            Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentTypeCode(), "D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(obtainTargetContNatureInfoComReqDto.getEvaluationTemplateId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-冗余评价模板ID不能为空", false);
            obtainTargetContNatureInfoComRespDto = indexSystemService.obtainTargetContNatureInfoCom(obtainTargetContNatureInfoComReqDto)/*vcase invoke isSameApp*/;


            obtainTargetContNatureInfoComRespDto_1 = obtainTargetContNatureInfoComRespDto;
            ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto = null;
            ImplementStandardDataFillRoleInfoComReqDto implementStandardDataFillRoleInfoComReqDto = new ImplementStandardDataFillRoleInfoComReqDto();
            implementStandardDataFillRoleInfoComReqDto.setIsPersonCharge("TRUE");//sourceId:1563449_1_61971
            implementStandardDataFillRoleInfoComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1563455_1_61971
            if (reqDto != null) {
                implementStandardDataFillRoleInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563451_1_61971
            }

            /*D3准备相关人入参数据(公共)[8371]   */
            Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getIsPersonCharge(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-是否负责人不能为空", false);
            Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getTargetCycleContentId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getUseScene(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-虚拟组织使用场景不能为空", false);
            implementStandardDataFillRoleInfoComRespDto = virtualOrgService.implementStandardDataFillRoleInfoCom(implementStandardDataFillRoleInfoComReqDto)/*vcase invoke isSameApp*/;


            implementStandardDataFillRoleInfoComRespDto_1 = implementStandardDataFillRoleInfoComRespDto;
        } else if ((reqDto != null && reqDto.getIsFinanceStandardData() != null && reqDto.getIsFinanceStandardData().equals("FALSE"))) {
            //elseif(D3准备目标内容周期与相关人等入参数据(公共).是否财务标准数据 等于 否)  61960

            if ((reqDto != null && reqDto.getIsParentCycle() != null || reqDto != null && reqDto.getEvaObjTargetCycleId() == null || reqDto != null && reqDto.getCycleId() == null)) {
                //if((D3准备目标内容周期与相关人等入参数据(公共).是否父周期 值不等于空  or D3准备目标内容周期与相关人等入参数据(公共).被评对象目标周期ID 值等于空  or D3准备目标内容周期与相关人等入参数据(公共).周期ID 值等于空 ))  61969

//异常结束 61970
                throw new BizException("500", "系统异常，请联系管理员！", false);
            }
            PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengComRespDto_2 = null;
            PreparationTargetCycleEternalGinsengComReqDto preparationTargetCycleEternalGinsengComReqDto_1 = new PreparationTargetCycleEternalGinsengComReqDto();
            if (reqDto != null) {
                preparationTargetCycleEternalGinsengComReqDto_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563438_1_61964
                preparationTargetCycleEternalGinsengComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563439_1_61964
                preparationTargetCycleEternalGinsengComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563440_1_61964
            }

            /*D3准备目标内容周期等入参数据(公共)[8541]   */
            Assert.isNull(preparationTargetCycleEternalGinsengComReqDto_1.getTargetCycleContentId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(preparationTargetCycleEternalGinsengComReqDto_1.getEvaluationTemplateId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-冗余评价模板ID不能为空", false);
            preparationTargetCycleEternalGinsengComRespDto_2 = preparationTargetCycleEternalGinsengCom(preparationTargetCycleEternalGinsengComReqDto_1)/*vcase invoke 同服务,同domain*/;


            preparationTargetCycleEternalGinsengComRespDto_1 = preparationTargetCycleEternalGinsengComRespDto_2;
            ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto_2 = null;
            ObtainTargetContNatureInfoComReqDto obtainTargetContNatureInfoComReqDto_1 = new ObtainTargetContNatureInfoComReqDto();
            if (reqDto != null) {
                obtainTargetContNatureInfoComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1565730_1_62035
                obtainTargetContNatureInfoComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1565731_1_62035
                obtainTargetContNatureInfoComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1565732_1_62035
            }

            /*D3获取目标内容属性信息(公共)[6952]   */
            Assert.isNull(obtainTargetContNatureInfoComReqDto_1.getTargetCycleContentId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(obtainTargetContNatureInfoComReqDto_1.getTargetCycleContentTypeCode(), "D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(obtainTargetContNatureInfoComReqDto_1.getEvaluationTemplateId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-冗余评价模板ID不能为空", false);
            obtainTargetContNatureInfoComRespDto_2 = indexSystemService.obtainTargetContNatureInfoCom(obtainTargetContNatureInfoComReqDto_1)/*vcase invoke isSameApp*/;


            obtainTargetContNatureInfoComRespDto_1 = obtainTargetContNatureInfoComRespDto_2;
            ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto_2 = null;
            ImplementStandardDataFillRoleInfoComReqDto implementStandardDataFillRoleInfoComReqDto_1 = new ImplementStandardDataFillRoleInfoComReqDto();
            implementStandardDataFillRoleInfoComReqDto_1.setIsPersonCharge("TRUE");//sourceId:1563449_1_61972
            implementStandardDataFillRoleInfoComReqDto_1.setUseScene("TARGET_PLAN_SCENE");//sourceId:1563455_1_61972
            if (reqDto != null) {
                implementStandardDataFillRoleInfoComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563451_1_61972
            }

            /*D3准备相关人入参数据(公共)[8371]   */
            Assert.isNull(implementStandardDataFillRoleInfoComReqDto_1.getIsPersonCharge(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-是否负责人不能为空", false);
            Assert.isNull(implementStandardDataFillRoleInfoComReqDto_1.getTargetCycleContentId(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementStandardDataFillRoleInfoComReqDto_1.getUseScene(), "D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-虚拟组织使用场景不能为空", false);
            implementStandardDataFillRoleInfoComRespDto_2 = virtualOrgService.implementStandardDataFillRoleInfoCom(implementStandardDataFillRoleInfoComReqDto_1)/*vcase invoke isSameApp*/;


            implementStandardDataFillRoleInfoComRespDto_1 = implementStandardDataFillRoleInfoComRespDto_2;
            PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto = null;
            PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto = new PreparationPreviousStandardDataResultComReqDto();
            if (reqDto != null) {
                preparationPreviousStandardDataResultComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1563839_1_61974
                preparationPreviousStandardDataResultComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1563835_1_61974
                preparationPreviousStandardDataResultComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801514_1_61974
                preparationPreviousStandardDataResultComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1812448_1_61974
            }

            /*D4准备上一标准数据结果(公共)[8542]   */
            Assert.isNull(preparationPreviousStandardDataResultComReqDto.getDataType(), "D3准备目标内容周期与相关人等入参数据(公共)-D4准备上一标准数据结果(公共)-数据点类型不能为空", false);
            preparationPreviousStandardDataResultComRespDto = fwCalcStandardDataClient.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            preparationPreviousStandardDataResultComRespDto_1 = preparationPreviousStandardDataResultComRespDto;
        } else {
            //else  61961

//异常结束 61962
            throw new BizException("500", "系统异常，请联系管理员！", false);
        }
        PreparationTargetCycleAndPeopleEternalGinsengComRespDto retData = new PreparationTargetCycleAndPeopleEternalGinsengComRespDto();
        if (preparationPreviousStandardDataResultComRespDto_1 != null) {
            retData.setDataResultId(preparationPreviousStandardDataResultComRespDto_1.getDataResultId());//SimpleFieldAssign//sourceId:1564266_1
            retData.setDataResult(preparationPreviousStandardDataResultComRespDto_1.getDataResult());//SimpleFieldAssign//sourceId:1564267_1
        }
        if (preparationTargetCycleEternalGinsengComRespDto_1 != null) {
            retData.setCycleId(preparationTargetCycleEternalGinsengComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1564046_1
            retData.setCycleStartTime(preparationTargetCycleEternalGinsengComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1565463_1
            retData.setCycleEndTime(preparationTargetCycleEternalGinsengComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1565464_1
            retData.setCycleTypeCode(preparationTargetCycleEternalGinsengComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1564048_1
            retData.setCycleTypeInstanceCode(preparationTargetCycleEternalGinsengComRespDto_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1564049_1
            retData.setEvaObjTargetCycleId(preparationTargetCycleEternalGinsengComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1564044_1
            retData.setTargetCycleContentId(preparationTargetCycleEternalGinsengComRespDto_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1564045_1
        }
        if (implementContentTypeChangeTableTypeComRespDto_1 != null) {
            retData.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:1567251_1
        }
        if (obtainTargetContNatureInfoComRespDto_1 != null) {
            retData.setRootTargetCategoryId(obtainTargetContNatureInfoComRespDto_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1565750_1
        }
        if (implementStandardDataFillRoleInfoComRespDto_1 != null) {
            retData.setVirtualOrgMemberId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgMemberId());//SimpleFieldAssign//sourceId:1580731_1
            retData.setVirtualOrgInductionRecordId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1564051_1
            retData.setRoleId(implementStandardDataFillRoleInfoComRespDto_1.getRoleId());//SimpleFieldAssign//sourceId:1564052_1
            retData.setRoleCode(implementStandardDataFillRoleInfoComRespDto_1.getRoleCode());//SimpleFieldAssign//sourceId:1564053_1
            retData.setRoleName(implementStandardDataFillRoleInfoComRespDto_1.getRoleName());//SimpleFieldAssign//sourceId:1564054_1
        }


        return retData;
    }

    /**
     * D3获取公共字段入参[8540]
     * gen by moon at 5/9/2024, 11:21:23 AM
     */
    @Trace(operationName = "D3获取公共字段入参")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainCalcStartTimeComRespDto obtainCalcStartTimeCom(ObtainCalcStartTimeComReqDto reqDto) {


        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
        ImplementFiveReceivingFieldRespDto receptionServiceRes_3 = null;
        OmsEvaluationTemplate omsEvaluationTemplate_1 = null;
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
        ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
        // TODO: 2024/5/5
        receptionServiceReq.setEventBatchUpdateCode("EVDB" + CommonFunctionHelper.getUid());//CUSTOM_CONVENTION//sourceId:1571415_1

        /*M3-准备数据1：事务内数据更新批次标识[8467]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEventBatchUpdateCode(), "D3获取公共字段入参-M3-准备数据1：事务内数据更新批次标识-事务内数据更新批次标识不能为空", false);
        receptionServiceRes = nbStandardData.implementFiveReceivingField(receptionServiceReq);


        receptionServiceRes_1 = receptionServiceRes;

//步骤1: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
        ImplementFiveReceivingFieldReqDto receptionServiceReq_1 = new ImplementFiveReceivingFieldReqDto();
        receptionServiceReq_1.setCalcStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1563357_1

        /*M3-准备数据2：计算开始时间[8467]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getCalcStartTime(), "D3获取公共字段入参-M3-准备数据2：计算开始时间-计算开始时间不能为空", false);
        receptionServiceRes_2 = nbStandardData.implementFiveReceivingField(receptionServiceReq_1);


        receptionServiceRes_3 = receptionServiceRes_2;

//步骤2: 3-2-02查评价模板详情 - queryEvaTempDetail
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1571378_1
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1571377_1
        }

        /*3-2-02准备数据3：评价主题ID、目标ID[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3获取公共字段入参-3-2-02准备数据3：评价主题ID、目标ID-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(), "D3获取公共字段入参-3-2-02准备数据3：评价主题ID、目标ID-主体生命周期不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationTemplate_1 = omsEvaluationTemplate;

        ObtainCalcStartTimeComRespDto retData = new ObtainCalcStartTimeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setEventBatchUpdateCode(receptionServiceRes_1.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1571418_1
        }
        if (receptionServiceRes_3 != null) {
            retData.setCalcStartTime(receptionServiceRes_3.getCalcStartTime());//SimpleFieldAssign//sourceId:1563368_1
        }
        if (omsEvaluationTemplate_1 != null) {
            retData.setEvaluationSubjectId(omsEvaluationTemplate_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1571393_1
            retData.setTargetId(omsEvaluationTemplate_1.getTargetId());//SimpleFieldAssign//sourceId:1571394_1
            retData.setIsOpenBudget(omsEvaluationTemplate_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1579994_1
            retData.setIsOpenBudgetReport(omsEvaluationTemplate_1.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1579995_1
        }


        return retData;
    }

    /**
     * D3准备目标内容周期等入参数据(公共)[8541]
     * gen by moon at 3/8/2024, 3:26:47 AM
     */
    @Trace(operationName = "D3准备目标内容周期等入参数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengCom(PreparationTargetCycleEternalGinsengComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
//步骤0: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1563269_1
        queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1563273_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1563271_1
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563274_1
            queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563270_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563272_1
        }

        /*3-3-09查被评对象目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
        Assert.isTrue(omsEvaluationObjectTargetCycle == null || omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() == null, "找不到数据，系统异常", false);

        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

        PreparationTargetCycleEternalGinsengComRespDto retData = new PreparationTargetCycleEternalGinsengComRespDto();
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563429_1
            retData.setCyclelAlias(omsEvaluationObjectTargetCycle_1.getCyclelAlias());//SimpleFieldAssign//sourceId:1563430_1
            retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563431_1
            retData.setCycleId(omsEvaluationObjectTargetCycle_1.getCycleId());//SimpleFieldAssign//sourceId:1563432_1
            retData.setCycleStandardName(omsEvaluationObjectTargetCycle_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1563433_1
            retData.setCycleStartTime(omsEvaluationObjectTargetCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1565459_1
            retData.setCycleEndTime(omsEvaluationObjectTargetCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1565460_1
            retData.setCycleTypeCode(omsEvaluationObjectTargetCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1563434_1
            retData.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1563435_1
            retData.setCycleNumberShortName(omsEvaluationObjectTargetCycle_1.getCycleNumberShortName());//SimpleFieldAssign//sourceId:1563436_1
        }


        return retData;
    }

    /**
     * D3执行财务账户内容数据推redis(公共)[8563]
     * gen by moon at 6/6/2024, 9:23:07 PM
     */
    @Trace(operationName = "D3执行财务账户内容数据推redis(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSingleFinancialAccountContentDataPushRedisComRespDto implementSingleFinancialAccountContentDataPushRedisCom(ImplementSingleFinancialAccountContentDataPushRedisComReqDto reqDto) {


        if ((reqDto != null && reqDto.getIsLastCycle() != null && reqDto.getIsLastCycle().equals("TRUE") && reqDto != null && reqDto.getAccountId() != null)) {
            //if((D3执行财务账户内容数据推redis(公共).是否末级周期 等于 是 and D3执行财务账户内容数据推redis(公共).账户ID 值不等于空 ))  62229

            QueryFullTemplateFundAccountListComRespDto queryFullTemplateFundAccountListComRespDto = null;
            QueryFullTemplateFundAccountListComReqDto queryFullTemplateFundAccountListComReqDto = new QueryFullTemplateFundAccountListComReqDto();
            queryFullTemplateFundAccountListComReqDto.setAccountObjectClass("CONTENT_TYPE");//sourceId:1569776_1_62230
            queryFullTemplateFundAccountListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1569778_1_62230
            if (reqDto != null) {
                queryFullTemplateFundAccountListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1569777_1_62230
                queryFullTemplateFundAccountListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1569779_1_62230
            }

            /*D7查全模板资金账户列表（用于刷全模板资金账户发牌）[8564]   */
            Assert.isNull(queryFullTemplateFundAccountListComReqDto.getThemeContentId(), "D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-主题内容ID不能为空", false);
            Assert.isNull(queryFullTemplateFundAccountListComReqDto.getAccountObjectClass(), "D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-账户关联主体分类类型不能为空", false);
            Assert.isNull(queryFullTemplateFundAccountListComReqDto.getSubjectLifeCycle(), "D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-主体生命周期不能为空", false);
            Assert.isNull(queryFullTemplateFundAccountListComReqDto.getSpaceId(), "D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-创建于空间ID不能为空", false);
            queryFullTemplateFundAccountListComRespDto = fwFinanceFinanceClient.queryFullTemplateFundAccountListCom(queryFullTemplateFundAccountListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((queryFullTemplateFundAccountListComRespDto != null && queryFullTemplateFundAccountListComRespDto.getFinanceAccountList() != null && queryFullTemplateFundAccountListComRespDto.getFinanceAccountList().size() > 0)) {
                //if(D7查全模板资金账户列表（用于刷全模板资金账户发牌）.资金账户列表数据集条数 大于 0)  62231

                OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
                QueryTargetContetCycleDetailReq queryTargetContetCycleDetailReq = new QueryTargetContetCycleDetailReq();
                queryTargetContetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1799661_1_68428
                if (reqDto != null) {
                    queryTargetContetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799659_1_68428
                    queryTargetContetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1799660_1_68428
                    queryTargetContetCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1799662_1_68428
                }

                /*3-3-09查询目标内容周期详情[9285]   */
                Assert.isNull(queryTargetContetCycleDetailReq.getEvaObjTargetCycleId(), "D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryTargetContetCycleDetailReq.getEvaluationTemplateId(), "D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetContetCycleDetailReq.getSubjectLifeCycle(), "D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-主体生命周期不能为空", false);
                Assert.isNull(queryTargetContetCycleDetailReq.getSpaceId(), "D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-创建于空间ID不能为空", false);
                omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetContetCycleDetail(queryTargetContetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: circulationCollections
                for (com.wicket.okrfinance.integration.dto.FinanceAccountDto circulationCollectionsRes : queryFullTemplateFundAccountListComRespDto.getFinanceAccountList()) {

                    OmsTargetAttributionCycle omsTargetAttributionCycle = null;
                    if (omsEvaluationObjectTargetCycle != null) {
                        QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq = new QueryTargetBelongCycleDetailReq();
                        queryTargetBelongCycleDetailReq.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1608414_1_63112
                        if (omsEvaluationObjectTargetCycle != null) {
                            queryTargetBelongCycleDetailReq.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1799666_1_63112
                            queryTargetBelongCycleDetailReq.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1799667_1_63112
                        }
                        if (circulationCollectionsRes != null) {
                            queryTargetBelongCycleDetailReq.setBelongToContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1608417_1_63112
                        }
                        if (reqDto != null) {
                            queryTargetBelongCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1608500_1_63112
                            queryTargetBelongCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1608412_1_63112
                        }

                        /*3-3-09-07查询目标归属父周期详情[8579]   */
                        Assert.isNull(queryTargetBelongCycleDetailReq.getEvaObjEntityId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-主树被评对象内容表主键ID不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq.getEvaObjTypeCode(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-主树被评对象类型编码不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq.getBelongToContentId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-数据归属内容表主键ID不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq.getParentSubMidCycleType(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-父子中过程周期类型不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq.getEvaluationTemplateId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-冗余评价模板ID不能为空", false);
                        omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    AddTargetCycleAndPeopleEternalGinsengRedisComRespDto addTargetCycleAndPeopleEternalGinsengRedisComRespDto = null;
                    if (omsTargetAttributionCycle != null && omsEvaluationObjectTargetCycle != null) {
                        AddTargetCycleAndPeopleEternalGinsengRedisComReqDto addTargetCycleAndPeopleEternalGinsengRedisComReqDto = new AddTargetCycleAndPeopleEternalGinsengRedisComReqDto();
                        addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setBusinessDataObject("ACCT_STD_DATA_TARGET_CONT_SNAP");//sourceId:1570033_1_62235
                        if (reqDto != null) {
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1570034_1_62235
                        }
                        if (omsTargetAttributionCycle != null) {
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue16(omsTargetAttributionCycle.getPreviousCycleId());//SimpleFieldAssign//sourceId:1799687_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue17(omsTargetAttributionCycle.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799688_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue1(omsTargetAttributionCycle.getTargetCycleId());//SimpleFieldAssign//sourceId:1570035_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue2(omsTargetAttributionCycle.getTargetCycleStartTime() != null ? String.valueOf(omsTargetAttributionCycle.getTargetCycleStartTime()) : "");//SimpleFieldAssign//sourceId:1570036_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue3(omsTargetAttributionCycle.getTargetCycleEndTime() != null ? String.valueOf(omsTargetAttributionCycle.getTargetCycleEndTime()) : "");//SimpleFieldAssign//sourceId:1570037_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue4(omsTargetAttributionCycle.getTargetCycleTypeCode());//SimpleFieldAssign//sourceId:1570038_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue5(omsTargetAttributionCycle.getTargetCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1570039_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue7(omsTargetAttributionCycle.getEntityId());//SimpleFieldAssign//sourceId:1570041_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue8(omsTargetAttributionCycle.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1570042_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue9(omsTargetAttributionCycle.getBelongToContentId());//SimpleFieldAssign//sourceId:1570043_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue10(omsTargetAttributionCycle.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1570044_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue11(omsTargetAttributionCycle.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1570045_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue12(omsTargetAttributionCycle.getBizRoleObjId());//SimpleFieldAssign//sourceId:1570046_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue13(omsTargetAttributionCycle.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1570047_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue14(omsTargetAttributionCycle.getBizRoleObjName());//SimpleFieldAssign//sourceId:1570048_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue15(omsTargetAttributionCycle.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1608769_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue20(omsTargetAttributionCycle.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1853109_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue21(omsTargetAttributionCycle.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1853110_1_62235
                        }
                        if (omsEvaluationObjectTargetCycle != null) {
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue19(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815799_1_62235
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue18(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815800_1_62235
                        }

                        /*D2新增目标内容周期与相关人等入参数据推reids(公共)[8565]   */
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getBusinessDataObject(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-业务数据对象不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue1(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue2(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期开始时间不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue3(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期结束时间不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue4(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期类型标识不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue19(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象内容表主键ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue18(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象类型编码不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue7(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-归属内容表主键ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue8(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表类型编码不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue9(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表主键ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue11(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人对象ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue12(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue13(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色标识不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue14(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象名称不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue15(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属个人ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue20(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-父子中过程周期类型不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue21(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-本目标归属周期的计算周期五模型不能为空", false);
                        addTargetCycleAndPeopleEternalGinsengRedisComRespDto = fwCompStandardDataClient.addTargetCycleAndPeopleEternalGinsengRedisCom(addTargetCycleAndPeopleEternalGinsengRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    if ((reqDto != null && reqDto.getOpenMidCycle() != null && reqDto.getOpenMidCycle().equals("TRUE"))) {
                        //if(D3执行财务账户内容数据推redis(公共).是否开启中期 等于 是)  68425

                        OmsTargetAttributionCycle omsTargetAttributionCycle_2 = null;
                        if (omsEvaluationObjectTargetCycle != null) {
                            QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq_1 = new QueryTargetBelongCycleDetailReq();
                            queryTargetBelongCycleDetailReq_1.setParentSubMidCycleType("MID_CYCLE");//sourceId:1799670_1_68426
                            if (omsEvaluationObjectTargetCycle != null) {
                                queryTargetBelongCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1799668_1_68426
                                queryTargetBelongCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1799669_1_68426
                            }
                            if (circulationCollectionsRes != null) {
                                queryTargetBelongCycleDetailReq_1.setBelongToContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1799671_1_68426
                            }
                            if (reqDto != null) {
                                queryTargetBelongCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1799672_1_68426
                                queryTargetBelongCycleDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1799673_1_68426
                            }

                            /*3-3-09-07查询目标归属中周期详情[8579]   */
                            Assert.isNull(queryTargetBelongCycleDetailReq_1.getEvaObjEntityId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-主树被评对象内容表主键ID不能为空", false);
                            Assert.isNull(queryTargetBelongCycleDetailReq_1.getEvaObjTypeCode(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-主树被评对象类型编码不能为空", false);
                            Assert.isNull(queryTargetBelongCycleDetailReq_1.getParentSubMidCycleType(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-父子中过程周期类型不能为空", false);
                            Assert.isNull(queryTargetBelongCycleDetailReq_1.getBelongToContentId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-数据归属内容表主键ID不能为空", false);
                            Assert.isNull(queryTargetBelongCycleDetailReq_1.getEvaluationTemplateId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-冗余评价模板ID不能为空", false);
                            Assert.isNull(queryTargetBelongCycleDetailReq_1.getSpaceId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-创建于空间ID不能为空", false);
                            omsTargetAttributionCycle_2 = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        AddTargetCycleAndPeopleEternalGinsengRedisComRespDto addTargetCycleAndPeopleEternalGinsengRedisComRespDto_1 = null;
                        if (omsTargetAttributionCycle_2 != null && omsEvaluationObjectTargetCycle != null) {
                            AddTargetCycleAndPeopleEternalGinsengRedisComReqDto addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1 = new AddTargetCycleAndPeopleEternalGinsengRedisComReqDto();
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setBusinessDataObject("ACCT_STD_DATA_TARGET_CONT_SNAP");//sourceId:1570033_1_68427
                            if (reqDto != null) {
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1570034_1_68427
                            }
                            if (omsTargetAttributionCycle_2 != null) {
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue16(omsTargetAttributionCycle_2.getPreviousCycleId());//SimpleFieldAssign//sourceId:1799687_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue17(omsTargetAttributionCycle_2.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799688_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue1(omsTargetAttributionCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1570035_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue2(omsTargetAttributionCycle_2.getCycleStartTime() != null ? String.valueOf(omsTargetAttributionCycle_2.getCycleStartTime()) : "");//SimpleFieldAssign//sourceId:1570036_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue3(omsTargetAttributionCycle_2.getCycleEndTime() != null ? String.valueOf(omsTargetAttributionCycle_2.getCycleEndTime()) : "");//SimpleFieldAssign//sourceId:1570037_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue4(omsTargetAttributionCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1570038_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue5(omsTargetAttributionCycle_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1570039_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue7(omsTargetAttributionCycle_2.getEntityId());//SimpleFieldAssign//sourceId:1570041_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue8(omsTargetAttributionCycle_2.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1570042_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue9(omsTargetAttributionCycle_2.getBelongToContentId());//SimpleFieldAssign//sourceId:1570043_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue10(omsTargetAttributionCycle_2.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1570044_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue11(omsTargetAttributionCycle_2.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1570045_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue12(omsTargetAttributionCycle_2.getBizRoleObjId());//SimpleFieldAssign//sourceId:1570046_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue13(omsTargetAttributionCycle_2.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1570047_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue14(omsTargetAttributionCycle_2.getBizRoleObjName());//SimpleFieldAssign//sourceId:1570048_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue15(omsTargetAttributionCycle_2.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1608769_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue20(omsTargetAttributionCycle_2.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1853109_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue21(omsTargetAttributionCycle_2.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1853110_1_68427
                            }

                            if (omsEvaluationObjectTargetCycle != null) {
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue19(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815799_1_68427
                                addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue18(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815800_1_68427
                            }

                            /*D2新增目标内容周期与相关人等入参数据推reids(公共)[8565]   */
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getBusinessDataObject(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-业务数据对象不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue1(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue2(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期开始时间不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue3(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期结束时间不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue4(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期类型标识不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue19(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象内容表主键ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue18(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象类型编码不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue7(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-归属内容表主键ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue8(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表类型编码不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue9(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表主键ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue11(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人对象ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue12(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue13(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色标识不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue14(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象名称不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue15(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属个人ID不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue20(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-父子中过程周期类型不能为空", false);
                            Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue21(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-本目标归属周期的计算周期五模型不能为空", false);
                            addTargetCycleAndPeopleEternalGinsengRedisComRespDto_1 = fwCompStandardDataClient.addTargetCycleAndPeopleEternalGinsengRedisCom(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                        }
                    }
                    OmsTargetAttributionCycle omsTargetAttributionCycle_4 = null;
                    if (omsEvaluationObjectTargetCycle != null) {
                        QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq_2 = new QueryTargetBelongCycleDetailReq();
                        queryTargetBelongCycleDetailReq_2.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1799680_1_68429
                        if (omsEvaluationObjectTargetCycle != null) {
                            queryTargetBelongCycleDetailReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1799674_1_68429
                            queryTargetBelongCycleDetailReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1799675_1_68429
                            queryTargetBelongCycleDetailReq_2.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1799676_1_68429
                        }
                        if (circulationCollectionsRes != null) {
                            queryTargetBelongCycleDetailReq_2.setBelongToContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1799677_1_68429
                        }
                        if (reqDto != null) {
                            queryTargetBelongCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1799678_1_68429
                            queryTargetBelongCycleDetailReq_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1799679_1_68429
                        }

                        /*3-3-09-07查询目标归属子周期详情[8579]   */
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getEvaObjEntityId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-主树被评对象内容表主键ID不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getEvaObjTypeCode(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-主树被评对象类型编码不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getCycleId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-归属周期ID不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getParentSubMidCycleType(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-父子中过程周期类型不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getBelongToContentId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-数据归属内容表主键ID不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getEvaluationTemplateId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-冗余评价模板ID不能为空", false);
                        Assert.isNull(queryTargetBelongCycleDetailReq_2.getSpaceId(), "D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-创建于空间ID不能为空", false);
                        omsTargetAttributionCycle_4 = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    AddTargetCycleAndPeopleEternalGinsengRedisComRespDto addTargetCycleAndPeopleEternalGinsengRedisComRespDto_2 = null;
                    if (omsTargetAttributionCycle_4 != null && omsEvaluationObjectTargetCycle != null) {
                        AddTargetCycleAndPeopleEternalGinsengRedisComReqDto addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2 = new AddTargetCycleAndPeopleEternalGinsengRedisComReqDto();
                        addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setBusinessDataObject("ACCT_STD_DATA_TARGET_CONT_SNAP");//sourceId:1570033_1_68430
                        if (reqDto != null) {
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1570034_1_68430
                        }
                        if (omsTargetAttributionCycle_4 != null) {
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue16(omsTargetAttributionCycle_4.getPreviousCycleId());//SimpleFieldAssign//sourceId:1799687_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue17(omsTargetAttributionCycle_4.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799688_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue1(omsTargetAttributionCycle_4.getCycleId());//SimpleFieldAssign//sourceId:1570035_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue2(omsTargetAttributionCycle_4.getCycleStartTime() != null ? String.valueOf(omsTargetAttributionCycle_4.getCycleStartTime()) : "");//SimpleFieldAssign//sourceId:1570036_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue3(omsTargetAttributionCycle_4.getCycleEndTime() != null ? String.valueOf(omsTargetAttributionCycle_4.getCycleEndTime()) : "");//SimpleFieldAssign//sourceId:1570037_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue4(omsTargetAttributionCycle_4.getCycleTypeCode());//SimpleFieldAssign//sourceId:1570038_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue5(omsTargetAttributionCycle_4.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1570039_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue7(omsTargetAttributionCycle_4.getEntityId());//SimpleFieldAssign//sourceId:1570041_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue8(omsTargetAttributionCycle_4.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1570042_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue9(omsTargetAttributionCycle_4.getBelongToContentId());//SimpleFieldAssign//sourceId:1570043_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue10(omsTargetAttributionCycle_4.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1570044_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue11(omsTargetAttributionCycle_4.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1570045_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue12(omsTargetAttributionCycle_4.getBizRoleObjId());//SimpleFieldAssign//sourceId:1570046_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue13(omsTargetAttributionCycle_4.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1570047_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue14(omsTargetAttributionCycle_4.getBizRoleObjName());//SimpleFieldAssign//sourceId:1570048_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue15(omsTargetAttributionCycle_4.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1608769_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue20(omsTargetAttributionCycle_4.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1853109_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue21(omsTargetAttributionCycle_4.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1853110_1_68430
                        }
                        if (omsEvaluationObjectTargetCycle != null) {
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue19(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815799_1_68430
                            addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue18(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815800_1_68430
                        }
                        /*D2新增目标内容周期与相关人等入参数据推reids(公共)[8565]   */
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getBusinessDataObject(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-业务数据对象不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue1(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue2(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期开始时间不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue3(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期结束时间不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue4(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期类型标识不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue19(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象内容表主键ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue18(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象类型编码不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue7(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-归属内容表主键ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue8(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表类型编码不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue9(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表主键ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue11(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人对象ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue12(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue13(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色标识不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue14(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象名称不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue15(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属个人ID不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue20(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-父子中过程周期类型不能为空", false);
                        Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue21(), "D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-本目标归属周期的计算周期五模型不能为空", false);
                        addTargetCycleAndPeopleEternalGinsengRedisComRespDto_2 = fwCompStandardDataClient.addTargetCycleAndPeopleEternalGinsengRedisCom(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
//ModelCode: circulationEnd
                }

            }
        }
        ImplementSingleFinancialAccountContentDataPushRedisComRespDto retData = new ImplementSingleFinancialAccountContentDataPushRedisComRespDto();


        return retData;
    }

    /**
     * D3-执行计算主观得分数据准备(公共)[8535]
     * gen by moon at 3/13/2024, 5:20:15 AM
     */
    @Trace(operationName = "D3-执行计算主观得分数据准备(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementPrepareForSubjectiveScoreComRespDto implementPrepareForSubjectiveScoreCom(ImplementPrepareForSubjectiveScoreComReqDto reqDto) {


        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 = null;
        QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto_1 = null;
        OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_1 = null;
        QueryTargetContExSetDetailComRespDto queryTargetContExSetDetailComRespDto_1 = null;
//步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
        //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
        ImplementFourthReceivingFieldReqDto receptionServiceReq = new ImplementFourthReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1561331_1
            receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1561332_1
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1561333_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561330_1
        }

        /*M3-接收入参字段[8259]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-被评对象目标周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(), "D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-关联目标内容类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-关联目标内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbStandardData.implementFourthReceivingField(receptionServiceReq);


//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SUBJECTIVE_RATING_TOTAL_VALUE");//CUSTOM_CONVENTION//sourceId:1561197_1
//queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1561198_1
//if(reqDto!=null){
//      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561196_1
//    }

        /*D2-3查主观评分满分值[2486]   */
//    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-执行计算主观得分数据准备(公共)-D2-3查主观评分满分值-开通对象ID不能为空",false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-执行计算主观得分数据准备(公共)-D2-3查主观评分满分值-配置项标识不能为空", false);
//Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-执行计算主观得分数据准备(公共)-D2-3查主观评分满分值-是否标准答案不能为空",false);
//      queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;

//步骤2: D2-3查询分组匹配结果转答案(公共)(跨服务） - queryClassMatchResultToAnswerDetailCom
        QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
        QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto = new QueryClassMatchResultToAnswerDetailComReqDto();
        queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("DECIMAL_POINT_RULES_SET_CLASS");//CUSTOM_CONVENTION//sourceId:1561306_1
        queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1561307_1
        if (reqDto != null) {
            queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561305_1
        }

        /*D2-3查小数规则配置[3088]   */
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D3-执行计算主观得分数据准备(公共)-D2-3查小数规则配置-开通对象ID不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(), "D3-执行计算主观得分数据准备(公共)-D2-3查小数规则配置-分组标识不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3-执行计算主观得分数据准备(公共)-D2-3查小数规则配置-是否标准答案不能为空", false);
        queryClassMatchResultToAnswerDetailComRespDto = confSchemeService.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryClassMatchResultToAnswerDetailComRespDto_1 = queryClassMatchResultToAnswerDetailComRespDto;

//步骤3: 3-3-09-02查被评对象目标周期权重详情 - queryEvaObjTargetCycleWeightDetail
        OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet = null;
        QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq = new QueryEvaObjTargetCycleWeightDetailReq();
        queryEvaObjTargetCycleWeightDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1561341_1
        if (reqDto != null) {
            queryEvaObjTargetCycleWeightDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1561339_1
            queryEvaObjTargetCycleWeightDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561340_1
        }

        /*3-3-09-02查被评对象目标周期权重详情[2649]   */
        Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaObjTargetCycleId(), "D3-执行计算主观得分数据准备(公共)-3-3-09-02查被评对象目标周期权重详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaluationTemplateId(), "D3-执行计算主观得分数据准备(公共)-3-3-09-02查被评对象目标周期权重详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getSubjectLifeCycle(), "D3-执行计算主观得分数据准备(公共)-3-3-09-02查被评对象目标周期权重详情-主体生命周期不能为空", false);
        omsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaObjTargetCycleWeightSet_1 = omsEvaObjTargetCycleWeightSet;

//步骤4: D3执行内容类型互转表类型(公共) - implementContentTypeChangeTableTypeCom
        ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
        ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto = new ImplementContentTypeChangeTableTypeComReqDto();
        if (reqDto != null) {
            implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1561348_1
        }

        /*D3执行内容类型互转表类型(公共)[5354]   */
        Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(), "D3-执行计算主观得分数据准备(公共)-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空", false);
        implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


//步骤5: D3-查询目标内容扩展设置(公共) - queryTargetContExSetDetailCom
        QueryTargetContExSetDetailComRespDto queryTargetContExSetDetailComRespDto = null;
        if (implementContentTypeChangeTableTypeComRespDto != null) {
            QueryTargetContExSetDetailComReqDto queryTargetContExSetDetailComReqDto = new QueryTargetContExSetDetailComReqDto();
            if (implementContentTypeChangeTableTypeComRespDto != null) {
                queryTargetContExSetDetailComReqDto.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1561344_1
            }
            if (reqDto != null) {
                queryTargetContExSetDetailComReqDto.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1561345_1
                queryTargetContExSetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561343_1
            }

            /*D3-查询目标内容扩展设置(公共)[5107]   */
            Assert.isNull(queryTargetContExSetDetailComReqDto.getTableTypeCode(), "D3-执行计算主观得分数据准备(公共)-D3-查询目标内容扩展设置(公共)-冗余内容表类型编码不能为空", false);
            Assert.isNull(queryTargetContExSetDetailComReqDto.getEntityId(), "D3-执行计算主观得分数据准备(公共)-D3-查询目标内容扩展设置(公共)-冗余内容表主键ID不能为空", false);
            Assert.isNull(queryTargetContExSetDetailComReqDto.getEvaluationTemplateId(), "D3-执行计算主观得分数据准备(公共)-D3-查询目标内容扩展设置(公共)-冗余评价模板ID不能为空", false);
            queryTargetContExSetDetailComRespDto = indexSystemService.queryTargetContExSetDetailCom(queryTargetContExSetDetailComReqDto)/*vcase invoke isSameApp*/;


            queryTargetContExSetDetailComRespDto_1 = queryTargetContExSetDetailComRespDto;
        }

        ImplementPrepareForSubjectiveScoreComRespDto retData = new ImplementPrepareForSubjectiveScoreComRespDto();
        if (queryConfItemMatchAnswerDetailComRespDto_1 != null) {
            retData.setSubjectiveRatingTotalValue(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:1561310_1
        }
        if (queryClassMatchResultToAnswerDetailComRespDto_1 != null) {
            retData.setSubjectiveScorePoint(queryClassMatchResultToAnswerDetailComRespDto_1.getSubjectiveScorePoint());//SimpleFieldAssign//sourceId:1561308_1
            retData.setDecimalDigitsLastRules(queryClassMatchResultToAnswerDetailComRespDto_1.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1561309_1
        }
        if (omsEvaObjTargetCycleWeightSet_1 != null) {
            retData.setWeightScore(omsEvaObjTargetCycleWeightSet_1.getWeightScore());//SimpleFieldAssign//sourceId:1561342_1
        }
        if (queryTargetContExSetDetailComRespDto_1 != null) {
            retData.setReportObjectSetCode(queryTargetContExSetDetailComRespDto_1.getReportObjectSetCode());//SimpleFieldAssign//sourceId:1561352_1
        }


        return retData;
    }

    /**
     * D3准备标准数据内容及周期数据(公共)[8650]
     * gen by moon at 4/24/2024, 4:11:54 PM
     */
    @Trace(operationName = "D3准备标准数据内容及周期数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public PreparationStandardDataContAndCycleComRespDto preparationStandardDataContAndCycleCom(PreparationStandardDataContAndCycleComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto_1 = null;
//步骤0: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1612875_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1612873_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1612874_1
        }

        /*3-3-09查被评对象目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3准备标准数据内容及周期数据(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3准备标准数据内容及周期数据(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3准备标准数据内容及周期数据(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

//步骤1: D3获取当前目标内容执行周期(公共) - obtainCurrentTargetContexeCuteCycleCom
        ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto = null;
        if (omsEvaluationObjectTargetCycle != null) {
            ObtainCurrentTargetContexeCuteCycleComReqDto obtainCurrentTargetContexeCuteCycleComReqDto = new ObtainCurrentTargetContexeCuteCycleComReqDto();
            if (reqDto != null) {
                obtainCurrentTargetContexeCuteCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1612755_1
                obtainCurrentTargetContexeCuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1612758_1
            }
            if (omsEvaluationObjectTargetCycle != null) {
                obtainCurrentTargetContexeCuteCycleComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1612756_1
                obtainCurrentTargetContexeCuteCycleComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1612757_1
            }

            /*D3获取当前目标内容执行周期(公共)[7501]   */
            Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getCycleId(), "D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-周期ID不能为空", false);
            Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetCycleContentId(), "D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetId(), "D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-冗余目标ID不能为空", false);
            Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getEvaluationTemplateId(), "D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-冗余评价模板ID不能为空", false);
            obtainCurrentTargetContexeCuteCycleComRespDto = executeCycleService.obtainCurrentTargetContexeCuteCycleCom(obtainCurrentTargetContexeCuteCycleComReqDto)/*vcase invoke isSameApp*/;


            obtainCurrentTargetContexeCuteCycleComRespDto_1 = obtainCurrentTargetContexeCuteCycleComRespDto;
        }

        PreparationStandardDataContAndCycleComRespDto retData = new PreparationStandardDataContAndCycleComRespDto();
        if (obtainCurrentTargetContexeCuteCycleComRespDto_1 != null) {
            retData.setCycleTypeCode(obtainCurrentTargetContexeCuteCycleComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1612883_1
        }
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setEvaluationSubjectId(omsEvaluationObjectTargetCycle_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1612882_1
            retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1742196_1
        }


        return retData;
    }

    /**
     * D3查询已提交的财务标准数据详情(公共)[9933]
     * gen by moon at 7/8/2024, 1:27:43 AM
     */
    @Trace(operationName = "D3查询已提交的财务标准数据详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuerySubmitFinanceStandardDataDetailComRespDto querySubmitFinanceStandardDataDetailCom(QuerySubmitFinanceStandardDataDetailComReqDto reqDto) {


        QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto_1 = null;
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
        //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
        ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1923415_1
            receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1922918_1
            receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1922919_1
        }

        /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getUpdateCycleId(), "D3查询已提交的财务标准数据详情(公共)-M3接收入参字段-更新周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEntityId(), "D3查询已提交的财务标准数据详情(公共)-M3接收入参字段-归属内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getThemeContentId(), "D3查询已提交的财务标准数据详情(公共)-M3接收入参字段-主题内容ID不能为空", false);
        receptionServiceRes = nbStandardData.implementElevenReceivingField(receptionServiceReq);


//步骤1: D4查询归属主体标准数据详情(公共) - queryStandardDataOfObjectDetailCom
        QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
        QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto = new QueryStandardDataOfObjectDetailComReqDto();
        queryStandardDataOfObjectDetailComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1920277_1
        queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1920592_1
        queryStandardDataOfObjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1920593_1
        if (reqDto != null) {
            queryStandardDataOfObjectDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1920591_1
            queryStandardDataOfObjectDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1923413_1
            queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1920282_1
        }

        /*D4查询财务预算支出金额[8850]   */
        Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getEntityId(), "D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-归属内容表主键ID不能为空", false);
        Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getUpdateCycleId(), "D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-更新周期ID不能为空", false);
        Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataType(), "D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-数据点类型不能为空", false);
        Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(), "D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-数据业务场景不能为空", false);
        Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(), "D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-主题内容ID不能为空", false);
        Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSubjectLifeCycle(), "D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-主体生命周期不能为空", false);
        queryStandardDataOfObjectDetailComRespDto = fwCalcStandardDataClient.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: D7查财务科目详情(公共) - queryAccountSubjectDetailCom
        QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto = null;
        if (queryStandardDataOfObjectDetailComRespDto != null) {
            QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto = new QueryAccountSubjectDetailComReqDto();
            if (queryStandardDataOfObjectDetailComRespDto != null) {
                queryAccountSubjectDetailComReqDto.setAccountSubjectld(queryStandardDataOfObjectDetailComRespDto.getExtendedField5());//SimpleFieldAssign//sourceId:1920570_1
            }

            /*D7查财务科目详情(公共)[7709]   */

            queryAccountSubjectDetailComRespDto = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            queryAccountSubjectDetailComRespDto_1 = queryAccountSubjectDetailComRespDto;
        }

//步骤3: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
        //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
        if (queryStandardDataOfObjectDetailComRespDto != null) {
            ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
            if (queryStandardDataOfObjectDetailComRespDto != null) {
                receptionServiceReq_1.setFinanceDataResultId(queryStandardDataOfObjectDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1922941_1
                receptionServiceReq_1.setBudgetDisburse(queryStandardDataOfObjectDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1923423_1
                receptionServiceReq_1.setParentBudgetDisburse(queryStandardDataOfObjectDetailComRespDto.getParentDataResult() != null ? String.valueOf(queryStandardDataOfObjectDetailComRespDto.getParentDataResult()) : "");//SimpleFieldAssign//sourceId:1923425_1
                receptionServiceReq_1.setBudgetDisburseUnit(queryStandardDataOfObjectDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1923424_1
            }

            /*M3接收财务数据出参[9482]  用于特殊方法接收上游入参。 */

            receptionServiceRes_2 = nbStandardData.implementElevenReceivingField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        }

        QuerySubmitFinanceStandardDataDetailComRespDto retData = new QuerySubmitFinanceStandardDataDetailComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setFinanceDataResultId(receptionServiceRes_3.getFinanceDataResultId());//SimpleFieldAssign//sourceId:1922947_1
            retData.setBudgetDisburse(receptionServiceRes_3.getBudgetDisburse());//SimpleFieldAssign//sourceId:1923429_1
            retData.setBudgetDisburseUnit(receptionServiceRes_3.getBudgetDisburseUnit());//SimpleFieldAssign//sourceId:1923430_1
            retData.setParentBudgetDisburse(receptionServiceRes_3.getParentBudgetDisburse());//SimpleFieldAssign//sourceId:1923431_1
        }
        if (queryAccountSubjectDetailComRespDto_1 != null) {
            retData.setAccountSubjectld(queryAccountSubjectDetailComRespDto_1.getAccountSubjectld());//SimpleFieldAssign//sourceId:1922953_1
            retData.setAccountSubjectName(queryAccountSubjectDetailComRespDto_1.getAccountSubjectName());//SimpleFieldAssign//sourceId:1922954_1
        }


        return retData;
    }

    //
}
